@vzn/vx 0.0.557 → 0.0.558

package/package.json

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

package/src/cache/inputs.ts

@@ -133,6 +133,13 @@ export interface ResolveInputsArgs {
    * only — global dedup so a root-level probe spawns once per run.
    */
   workspaceRuntimeCache?: Map<string, Promise<string>>
+  /**
+   * Answer this task's probes apart from every other task's, in both memos
+   * above: the probes may read what its upstream wrote this run, so an
+   * answer another task took before that write is not this task's (X-34).
+   * The task id.
+   */
+  runtimeScope?: string
   /**
    * Run-scoped memo for `cache.inputs.workspaceFiles`, keyed by the
    * declaration and valid for one enumeration snapshot. A Turbo-mapped
@@ -207,14 +214,16 @@ export async function resolveInputs(args: ResolveInputsArgs): Promise<ResolvedIn
             args.projectDir,
             projectBinDirs(args.projectDir, args.workspaceRoot),
             args.runtimeCache,
-            `${args.projectDir}\0`,
+            args.runtimeScope === undefined
+              ? `${args.projectDir}\0`
+              : `${args.projectDir}\0${args.runtimeScope}\0`,
           ),
           resolveRuntimeValues(
             wsRuntimeDecl,
             args.workspaceRoot,
             [path.join(args.workspaceRoot, 'node_modules', '.bin')],
             args.workspaceRuntimeCache,
-            '',
+            args.runtimeScope === undefined ? '' : `\0${args.runtimeScope}\0`,
           ),
         ])
   return {

package/src/orchestrator/execute-task.ts

@@ -167,6 +167,8 @@ export interface ExecuteArgs {
   gitFilesCache?: GitFilesCache
   /** Per-run memo for derived hashes (package.json bytes + task config). */
   hashCache?: HashCache
+  /** The run's `probesAfterWrites`, handed to every key this task takes. */
+  probesAfterWrites?: ReadonlySet<string>
   /**
    * Up-front probe result from the local short-circuit classify, when
    * this task was stable + cacheable + local-read. Reused here so there
@@ -715,6 +717,9 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       nestedProjectDirs: args.nestedProjectDirs,
       ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
       ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
+      ...(args.probesAfterWrites !== undefined
+        ? { probesAfterWrites: args.probesAfterWrites }
+        : {}),
     }))
 
   // The local no-op half of `exec.remote: 'only'`: no remote executor took
@@ -814,6 +819,9 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         captureInto: captured,
         ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
         ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
+        ...(args.probesAfterWrites !== undefined
+          ? { probesAfterWrites: args.probesAfterWrites }
+          : {}),
       })
     : undefined
   // A name only `exec.env.secret` makes secret is not one the name rule

package/src/orchestrator/keyed-projects.ts

@@ -50,7 +50,7 @@ export function keyedProjects(
         continue
       }
       if (deps === undefined) {
-        frame[1] = folded(node, nodeOf)
+        frame[1] = foldedDeps(node, nodeOf)
         for (const { node: dep } of frame[1]) if (!below.has(dep.id)) stack.push([dep, undefined])
         continue
       }
@@ -75,7 +75,7 @@ export function keyedProjects(
  * edges and lacked the dropped ones: the sandbox granted a sibling the key
  * does not answer for.
  */
-function folded(node: TaskNode, nodeOf: (id: string) => TaskNode): FoldCandidate[] {
+export function foldedDeps(node: TaskNode, nodeOf: (id: string) => TaskNode): FoldCandidate[] {
   const candidates: FoldCandidate[] = []
   for (const id of keyedDeps(node)) {
     const dep = nodeOf(id)

package/src/orchestrator/run.ts

@@ -86,6 +86,7 @@ import {
 } from './run-context.js'
 import { startRemotePrefetch } from './remote-prefetch.js'
 import { startLocalShortCircuit, type ShortCircuit } from './local-shortcircuit.js'
+import { probesAfterWrites } from './stable-keys.js'
 
 import { assembleRunRecords } from './run-records.js'
 import { hasEnded, selectKeepAlive, shutdownPersistent } from './persistent.js'
@@ -927,6 +928,7 @@ async function runOnBus(
     // when a sink exists.
     const explainMiss =
       telemetry === undefined ? undefined : createMissExplainer(prepared.localCache.dbHandle())
+    const lateProbes = probesAfterWrites(nodes, workspaceRoot)
     const buildExecuteArgs = (node: TaskNode, upstream: TaskOutcome[], reuseProbe = true) => {
       const probe = reuseProbe ? shortCircuit.preProbed.get(node.id) : undefined
       const upfrontKey = shortCircuit.uncachedKeys.get(node.id)
@@ -961,6 +963,7 @@ async function runOnBus(
         ...(explainMiss !== undefined ? { explainMiss } : {}),
         gitFilesCache,
         hashCache,
+        probesAfterWrites: lateProbes,
         ...(probe !== undefined ? { preProbed: probe } : {}),
         ...(upfrontKey !== undefined ? { upfrontKey } : {}),
         ...(tainted ? { taintedUpstream: true } : {}),
@@ -988,6 +991,7 @@ async function runOnBus(
         nestedDirsByProject,
         gitFilesCache,
         hashCache,
+        probesAfterWrites: lateProbes,
       },
       buildExecuteArgs,
     })

package/src/orchestrator/stable-keys.ts

@@ -15,6 +15,7 @@ import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import type { CacheLayer, GitFilesCache } from '../cache/index.js'
 import { isLiteralPattern, normalizeGlob, relPosix } from '../util/index.js'
 import { commandWriteReach, mayWriteFingerprint, undeclaredWriteReach } from './sandbox-request.js'
+import { foldedDeps } from './keyed-projects.js'
 import { computeGroupKey, computeTaskHash, type HashCache } from './task-hash.js'
 import { filterUpstreamHashes, keyUpstream } from './upstream.js'
 
@@ -53,6 +54,7 @@ export interface StableKey {
  */
 export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<StableKey[]> {
   const order = topoOrder(args.nodes)
+  const late = probesAfterWrites(args.nodes, args.workspaceRoot)
   const keyById = new Map<string, string>()
   const unstableById = new Set<string>()
   // Transitive-upstream output producers, accumulated in topo order — the
@@ -203,6 +205,13 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
     if (unfolded !== undefined) unfoldedById.set(id, unfolded)
     if (wsRewriter) wsRewriters.add(id)
 
+    // Its probes answer only once its writers have run, so it has no key
+    // up front, and its dependants inherit that.
+    if (late.has(id)) {
+      unstableById.add(id)
+      continue
+    }
+
     if (isGroupTask(node)) {
       // Groups have no exec/cache; they only fold upstream keys so
       // dependents that filter inputs.tasks through the group still
@@ -271,6 +280,86 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
   return stableKeys
 }
 
+const probesAfterWritesOf = new WeakMap<ReadonlyMap<string, TaskNode>, ReadonlySet<string>>()
+
+/**
+ * The cached tasks whose `cache.inputs.runtime` / `workspaceRuntime` probes
+ * may read what an upstream writes this run while the key folds nothing of
+ * that upstream (X-34). A probe is a shell command and may read anywhere,
+ * so no glob bounds it, and its answer taken before the writer ran is the
+ * previous run's bytes. Such a task is never stable (`deriveStableKeys`
+ * takes no key for it), and its probes are answered for it alone, after
+ * its upstream ran (`ComputeHashArgs.probesAfterWrites`).
+ *
+ * A writer is any upstream whose command may write (`commandWriteReach`)
+ * or that declares outputs. A key that folds the writer's covers what it
+ * writes, as for a rewriter in `deriveStableKeys`: an early answer then
+ * costs a spurious miss on the run after the bytes change, never a stale
+ * hit, and such a probe keeps the run's shared answer — one spawn per run,
+ * not per task. So only a writer the key does not fold, transitively
+ * (`tasks: []`, a filter that leaves it out, an order-only edge), makes
+ * the probe wait.
+ *
+ * Once per graph: run, admission and both up-front passes ask the same map.
+ */
+export function probesAfterWrites(
+  nodes: ReadonlyMap<string, TaskNode>,
+  workspaceRoot: string,
+): ReadonlySet<string> {
+  const memo = probesAfterWritesOf.get(nodes)
+  if (memo !== undefined) return memo
+  const late = new Set<string>()
+  probesAfterWritesOf.set(nodes, late)
+  const probes = (n: TaskNode): boolean =>
+    (n.config.cache?.inputs?.runtime?.length ?? 0) > 0 ||
+    (n.config.cache?.inputs?.workspaceRuntime?.length ?? 0) > 0
+  let anyProbe = false
+  for (const n of nodes.values()) {
+    if (probes(n)) {
+      anyProbe = true
+      break
+    }
+  }
+  if (!anyProbe) return late
+  // A sandbox with no write grant still writes the declared outputs. A
+  // fingerprinted file is only writable where `commandWriteReach` is not
+  // 'none' already (`mayWriteFingerprint`).
+  const writers = new Set<string>()
+  for (const n of nodes.values()) {
+    if (
+      commandWriteReach(n, workspaceRoot) !== 'none' ||
+      (n.config.cache?.outputs.files.length ?? 0) > 0 ||
+      (n.config.cache?.outputs.workspaceFiles?.length ?? 0) > 0
+    )
+      writers.add(n.id)
+  }
+  const nodeOf = (id: string): TaskNode => nodes.get(id)!
+  // Any writer runs before the task; one its key does not fold does.
+  const writerBelow = new Set<string>()
+  const unfoldedBelow = new Set<string>()
+  for (const id of topoOrder(nodes)) {
+    const node = nodes.get(id)!
+    let writer = false
+    let unfolded = false
+    // No filter and no order-only edge: the key folds every dependency.
+    const foldsAll = node.orderOnly === undefined && node.config.cache?.inputs?.tasks === undefined
+    let folds: Set<string> | undefined
+    for (const dep of node.deps) {
+      if (!nodes.has(dep)) continue
+      const depWrites = writerBelow.has(dep) || writers.has(dep)
+      if (depWrites) writer = true
+      if (unfolded || !depWrites) continue
+      const folded =
+        foldsAll || (folds ??= new Set(foldedDeps(node, nodeOf).map((c) => c.node.id))).has(dep)
+      unfolded = folded ? unfoldedBelow.has(dep) : true
+    }
+    if (writer) writerBelow.add(id)
+    if (unfolded) unfoldedBelow.add(id)
+    if (unfolded && node.config.cache !== undefined && probes(node)) late.add(id)
+  }
+  return late
+}
+
 /**
  * Does this task's key fold the dependency's? What `computeTaskHash` folds
  * (`filterUpstreamHashes` over the same synthetic outcomes); a group folds
@@ -519,7 +608,7 @@ class ProjectSet implements ProjectNames {
   }
 }
 
-function topoOrder(nodes: Map<string, TaskNode>): string[] {
+function topoOrder(nodes: ReadonlyMap<string, TaskNode>): string[] {
   const indegree = new Map<string, number>()
   const dependents = new Map<string, string[]>()
   for (const node of nodes.values()) {

package/src/orchestrator/task-hash.ts

@@ -88,6 +88,12 @@ export interface ComputeHashArgs {
    * site, so the recorded set can't drift from the key.
    */
   captureInto?: TaskInputComponent[]
+  /**
+   * The run's tasks whose runtime probes may read an upstream's writes
+   * (`probesAfterWrites`): such a task's probes are answered for it alone,
+   * after its upstream ran, never from the run's shared memo.
+   */
+  probesAfterWrites?: ReadonlySet<string>
 }
 
 /**
@@ -268,6 +274,7 @@ async function resolveKeyInput(args: ComputeHashArgs): Promise<CacheKeyInput> {
     ownWorkspaceOutputs: cacheCfg?.outputs.workspaceFiles ?? [],
     nestedProjectDirs: args.nestedProjectDirs,
     ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
+    ...(args.probesAfterWrites?.has(args.node.id) === true ? { runtimeScope: args.node.id } : {}),
     ...(args.hashCache !== undefined
       ? {
           runtimeCache: args.hashCache.runtime,