@vzn/vx 0.0.615 → 0.0.616

package/package.json

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

package/src/orchestrator/execute-task.ts

@@ -76,12 +76,13 @@ export { restoreHit, type RestoreHitArgs } from './hit-restore.js'
 import type { DeferredOutputs } from './deferred-outputs.js'
 import type { Logger } from './logger.js'
 import {
-  computeGroupKey,
+  computeGroupHash,
   computeTaskHash,
   describeTaskInputs,
   type HashCache,
   movedInput,
   type TaskInputComponent,
+  type UpfrontGroupKey,
 } from './task-hash.js'
 import { getContext } from './remote-prefetch.js'
 import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
@@ -190,6 +191,11 @@ export interface ExecuteArgs {
    * used verbatim instead of deriving the same key again.
    */
   upfrontKey?: string
+  /**
+   * An unkeyed group's up-front key (`deriveStableKeys`' `groupKeys`): used
+   * verbatim when the live upstream folds the same ids and keys.
+   */
+  upfrontGroupKey?: UpfrontGroupKey
   /**
    * Start the sandbox runtime, on the first task that executes inside one
    * (run.ts, `prepareSandbox`). Absent when no task in the run declares a
@@ -263,17 +269,25 @@ export async function executeTask(args: ExecuteArgs): Promise<TaskOutcome> {
  */
 async function executeGroupTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const wallclockNs = process.hrtime.bigint() - args.runStartHrTimeNs
-  const hash = await computeGroupKey({
-    node: args.node,
-    upstream: args.upstream,
-    workspaceRoot: args.workspaceRoot,
-    workspaceFingerprint: args.workspaceFingerprint,
-    cache: args.cache,
-    forwardArgs: args.forwardArgs,
-    nestedProjectDirs: args.nestedProjectDirs,
-    ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
-    ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
-  })
+  // `computeGroupKey`: an unkeyed group's key is its upstream's alone, so
+  // the up-front one stands when that upstream is unchanged.
+  const upfront = args.upfrontGroupKey
+  const hash =
+    args.node.config.cache === undefined
+      ? upfront !== undefined && sameUpstream(args.upstream, upfront.upstream)
+        ? upfront.key
+        : computeGroupHash(args.upstream)
+      : await computeTaskHash({
+          node: args.node,
+          upstream: args.upstream,
+          workspaceRoot: args.workspaceRoot,
+          workspaceFingerprint: args.workspaceFingerprint,
+          cache: args.cache,
+          forwardArgs: args.forwardArgs,
+          nestedProjectDirs: args.nestedProjectDirs,
+          ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
+          ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
+        })
   return {
     node: args.node,
     status: 'success',
@@ -288,6 +302,17 @@ async function executeGroupTask(args: ExecuteArgs): Promise<TaskOutcome> {
   }
 }
 
+/** The same ids with the same keys, in order: what `computeGroupHash` reads. */
+function sameUpstream(live: TaskOutcome[], upfront: TaskOutcome[]): boolean {
+  if (live.length !== upfront.length) return false
+  for (let i = 0; i < live.length; i++) {
+    const a = live[i]
+    const b = upfront[i]!
+    if (a === undefined || a.node.id !== b.node.id || a.hash !== b.hash) return false
+  }
+  return true
+}
+
 /**
  * Persistent task: dev server / file watcher / daemon. Spawn, wait
  * for ready (regex match or immediate), stash the subprocess in the

package/src/orchestrator/local-shortcircuit.ts

@@ -45,7 +45,7 @@ import { normalizeGlob, relPosix, span, staticPrefix } from '../util/index.js'
 import type { CacheEntry, CacheLayer, GitFilesCache } from '../cache/index.js'
 import type { TaskNode } from '../graph/index.js'
 import { deriveStableKeys, workspaceInputsReach } from './stable-keys.js'
-import type { HashCache } from './task-hash.js'
+import type { HashCache, UpfrontGroupKey } from './task-hash.js'
 import { getContext } from './remote-prefetch.js'
 
 export interface ShortCircuitArgs {
@@ -91,6 +91,8 @@ export interface ShortCircuit {
    * again (`deriveStableKeys`' `uncachedKeys`).
    */
   uncachedKeys: Map<string, string>
+  /** Unkeyed group id → its up-front key (`deriveStableKeys`' `groupKeys`). */
+  groupKeys: Map<string, UpfrontGroupKey>
 }
 
 /**
@@ -105,11 +107,17 @@ export interface ShortCircuit {
 export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<ShortCircuit> {
   let stableKeys
   const uncachedKeys = new Map<string, string>()
+  const groupKeys = new Map<string, UpfrontGroupKey>()
   const endKeys = span('stable keys')
   try {
-    stableKeys = await deriveStableKeys({ ...args, uncachedKeys })
+    stableKeys = await deriveStableKeys({ ...args, uncachedKeys, groupKeys })
   } catch {
-    return { preProbed: new Map(), restoreTier: new Set(), uncachedKeys: new Map() }
+    return {
+      preProbed: new Map(),
+      restoreTier: new Set(),
+      uncachedKeys: new Map(),
+      groupKeys: new Map(),
+    }
   } finally {
     endKeys()
   }
@@ -120,14 +128,14 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   const preProbed = new Map<string, ProbedEntry>()
   const restoreTier = new Set<string>()
   if (candidates.length === 0 && uncachedKeys.size === 0) {
-    return { preProbed, restoreTier, uncachedKeys }
+    return { preProbed, restoreTier, uncachedKeys, groupKeys }
   }
 
   const keptOut = restoreTierExclusions(args.nodes, args.workspaceRoot)
   // A root-anchored output may land in a project no edge leads from, so an
   // uncached key there is derived again once the writer may have run.
   for (const id of keptOut) uncachedKeys.delete(id)
-  if (candidates.length === 0) return { preProbed, restoreTier, uncachedKeys }
+  if (candidates.length === 0) return { preProbed, restoreTier, uncachedKeys, groupKeys }
 
   // Bounded pool over the stable candidates: probe local ONCE each. A
   // confirmed hit becomes restore-tier (unless workspace outputs disable
@@ -153,7 +161,7 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
         preProbed.set(node.id, { hash, hit })
         if (hit !== null && !keptOut.has(node.id)) restoreTier.add(node.id)
       }
-      return { preProbed, restoreTier, uncachedKeys }
+      return { preProbed, restoreTier, uncachedKeys, groupKeys }
     } catch {
       // Fall through to the per-hash pool, which isolates a failing probe
       // to its own task.
@@ -176,7 +184,7 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   }
   await Promise.all(Array.from({ length: workers }, () => pump()))
 
-  return { preProbed, restoreTier, uncachedKeys }
+  return { preProbed, restoreTier, uncachedKeys, groupKeys }
 }
 
 /**

package/src/orchestrator/run.ts

@@ -54,6 +54,7 @@ import { isDefaultBuild } from './projects.js'
 import { prepareSandbox } from './sandbox-request.js'
 import type { OutputDirSnapshot, SaveFacts } from './miss-save.js'
 import { admitTasks, taintTracker } from './admission.js'
+import type { ExecuteArgs } from './execute-task.js'
 import { excludedTaint } from './excluded-keys.js'
 import { keyUpstream } from './upstream.js'
 import { busLogger, createEventBus, terminalSubscriber, type EventBus } from './events.js'
@@ -116,6 +117,7 @@ const emptyShortCircuit = (): ShortCircuit => ({
   preProbed: new Map(),
   restoreTier: new Set(),
   uncachedKeys: new Map(),
+  groupKeys: new Map(),
 })
 
 /**
@@ -938,9 +940,19 @@ async function runOnBus(
     // The scheduler's fail-fast stop, as the retry loop of a task already
     // in flight sees it.
     const failFast = new AbortController()
-    const buildExecuteArgs = (node: TaskNode, upstream: TaskOutcome[], reuseProbe = true) => {
+    // A literal of the fields every task carries, then each optional one
+    // assigned only when present: twelve conditional spreads per task cost
+    // ~18 ms of object copying on a 1,090-package warm run (X-149).
+    const track = telemetry?.track
+    const armSandbox = sandboxArmer !== null ? () => sandboxArmer.arm() : undefined
+    const buildExecuteArgs = (
+      node: TaskNode,
+      upstream: TaskOutcome[],
+      reuseProbe = true,
+    ): ExecuteArgs => {
       const probe = reuseProbe ? shortCircuit.preProbed.get(node.id) : undefined
       const upfrontKey = shortCircuit.uncachedKeys.get(node.id)
+      const upfrontGroupKey = shortCircuit.groupKeys.get(node.id)
       if (
         options.continueMode === 'always' &&
         node.deps.some((d) => deadServerBehind(nodes, serverDied, d) !== undefined)
@@ -948,7 +960,7 @@ async function runOnBus(
         taintSeeds.add(node.id)
       const tainted = taint.judge(node, upstream)
       if (tainted) taintedRan.add(node.id)
-      return {
+      const a: ExecuteArgs = {
         node,
         upstream,
         workspaceRoot,
@@ -956,31 +968,18 @@ async function runOnBus(
         cache,
         cachePolicy: policy,
         forwardArgs: options.forwardArgs,
-        ...(options.retries !== undefined ? { retries: options.retries } : {}),
-        ...(taskTimeoutDefault !== undefined ? { timeout: taskTimeoutDefault } : {}),
         log,
         executor: placements.executors.get(node.id) ?? UNPLACED_EXECUTOR,
-        ...(download.modeOf.get(node.id) === 'deferred' ? { download: 'deferred' as const } : {}),
         deferred: deferredOutputs,
-        ...(placements.remoteOnlyNoop.has(node.id) ? { remoteOnlyNoop: true } : {}),
-        ...(placements.remoteOnly.has(node.id) ? { remoteOnly: true } : {}),
         nestedProjectDirs: nestedDirsByProject.get(node.projectName) ?? [],
         cacheDir,
         runStartHrTimeNs,
         persistentRegistry,
         liveChildren,
-        ...(telemetry?.track !== undefined ? { track: telemetry.track } : {}),
-        ...(explainMiss !== undefined ? { explainMiss } : {}),
         gitFilesCache,
         hashCache,
         probesAfterWrites: lateProbes,
-        ...(probe !== undefined ? { preProbed: probe } : {}),
-        ...(upfrontKey !== undefined ? { upfrontKey } : {}),
-        ...(tainted ? { taintedUpstream: true } : {}),
-        ...(dependedOn.has(node.id) ? {} : { noDependants: true as const }),
-        ...(holders.has(node.id) ? { terminal: true as const } : {}),
         fingerprintWatch,
-        ...(sandboxArmer !== null ? { armSandbox: () => sandboxArmer.arm() } : {}),
         keyedProjects: keyed,
         outputDirSnapshots,
         deferSave: saveLane.defer,
@@ -988,6 +987,21 @@ async function runOnBus(
         stopSignal: stopRun.signal,
         failFast: failFast.signal,
       }
+      if (options.retries !== undefined) a.retries = options.retries
+      if (taskTimeoutDefault !== undefined) a.timeout = taskTimeoutDefault
+      if (download.modeOf.get(node.id) === 'deferred') a.download = 'deferred'
+      if (placements.remoteOnlyNoop.has(node.id)) a.remoteOnlyNoop = true
+      if (placements.remoteOnly.has(node.id)) a.remoteOnly = true
+      if (track !== undefined) a.track = track
+      if (explainMiss !== undefined) a.explainMiss = explainMiss
+      if (probe !== undefined) a.preProbed = probe
+      if (upfrontKey !== undefined) a.upfrontKey = upfrontKey
+      if (upfrontGroupKey !== undefined) a.upfrontGroupKey = upfrontGroupKey
+      if (tainted) a.taintedUpstream = true
+      if (!dependedOn.has(node.id)) a.noDependants = true
+      if (holders.has(node.id)) a.terminal = true
+      if (armSandbox !== undefined) a.armSandbox = armSandbox
+      return a
     }
 
     const executeWithDedup = admitTasks({

package/src/orchestrator/stable-keys.ts

@@ -16,7 +16,12 @@ 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 {
+  computeGroupHash,
+  computeTaskHash,
+  type HashCache,
+  type UpfrontGroupKey,
+} from './task-hash.js'
 import { filterUpstreamHashes, keyedOutcome, keyUpstream } from './upstream.js'
 
 export interface DeriveStableKeysArgs {
@@ -33,6 +38,11 @@ export interface DeriveStableKeysArgs {
    * that key reads, so execute-task need not derive it a second time.
    */
   uncachedKeys?: Map<string, string>
+  /**
+   * Filled with each unkeyed group's key and the upstream it folded:
+   * execute-task reuses the key when the live upstream matches.
+   */
+  groupKeys?: Map<string, UpfrontGroupKey>
 }
 
 export interface StableKey {
@@ -217,20 +227,27 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
       // dependents that filter inputs.tasks through the group still
       // cascade (and forward their producers, above). They inherit
       // instability from any unstable member.
-      keyById.set(
-        id,
-        await computeGroupKey({
-          node,
-          upstream,
-          workspaceRoot: args.workspaceRoot,
-          workspaceFingerprint: args.workspaceFingerprint,
-          cache: args.cache,
-          forwardArgs: args.forwardArgs,
-          nestedProjectDirs: args.nestedDirsByProject.get(node.projectName) ?? [],
-          gitFilesCache: args.gitFilesCache,
-          hashCache: args.hashCache,
-        }),
-      )
+      // `computeGroupKey`, with the unkeyed branch kept synchronous.
+      if (node.config.cache === undefined) {
+        const key = computeGroupHash(upstream)
+        keyById.set(id, key)
+        args.groupKeys?.set(id, { key, upstream })
+      } else {
+        keyById.set(
+          id,
+          await computeTaskHash({
+            node,
+            upstream,
+            workspaceRoot: args.workspaceRoot,
+            workspaceFingerprint: args.workspaceFingerprint,
+            cache: args.cache,
+            forwardArgs: args.forwardArgs,
+            nestedProjectDirs: args.nestedDirsByProject.get(node.projectName) ?? [],
+            gitFilesCache: args.gitFilesCache,
+            hashCache: args.hashCache,
+          }),
+        )
+      }
       if (node.deps.some((d) => unstableById.has(d))) unstableById.add(id)
       continue
     }

package/src/orchestrator/task-hash.ts

@@ -432,6 +432,16 @@ export async function computeGroupKey(args: ComputeHashArgs): Promise<string> {
   return computeTaskHash(args)
 }
 
+/**
+ * An unkeyed group's key is `computeGroupHash` of its upstream alone, so a
+ * live upstream with the same ids and keys in the same order derives these
+ * bytes (execute-task's `sameUpstream`).
+ */
+export interface UpfrontGroupKey {
+  key: string
+  upstream: TaskOutcome[]
+}
+
 /**
  * Derive a stable hash for a group task (no `exec`) from its upstream
  * outcomes. Lets downstream tasks that filter `inputs.tasks` to

package/src/orchestrator/upstream.ts

@@ -30,13 +30,9 @@ export function keyUpstream(node: TaskNode, upstream: TaskOutcome[]): TaskOutcom
 
 /** A dependency as a key reads it: only `node` and `hash` matter. */
 export function keyedOutcome(node: TaskNode, hash: string | undefined): TaskOutcome {
-  return {
-    node,
-    status: 'success',
-    exitCode: 0,
-    durationMs: 0,
-    ...(hash !== undefined ? { hash } : {}),
-  }
+  const o: TaskOutcome = { node, status: 'success', exitCode: 0, durationMs: 0 }
+  if (hash !== undefined) o.hash = hash
+  return o
 }
 
 /** `node.deps` less its ordering-only edges: the dependencies a key may fold. */