@vzn/vx 0.0.614 → 0.0.616

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.614",
+  "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.614",
-    "@vzn/vx-linux-arm64": "0.0.614",
-    "@vzn/vx-darwin-x64": "0.0.614",
-    "@vzn/vx-darwin-arm64": "0.0.614"
+    "@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/graph/task-graph.ts

@@ -2,6 +2,7 @@ import type { ProjectConfig, TaskConfig, WorkspaceRules } from '../config.js'
 import {
   asTrees,
   isLiteralPattern,
+  normalizeGlob,
   relPosix,
   splitNegations,
   staticPrefix,
@@ -1152,6 +1153,64 @@ function collideAcross(
  */
 const GLOB_HEAD_END = /[*?{}\\!]/
 
+/** `firstSegment`'s answer for a glob that can start anywhere. */
+const ANYWHERE = ''
+
+/** Where a glob's first segment ends: a separator, or anything `GLOB_HEAD_END` stops at. */
+const FIRST_SEGMENT_END = /[*?{}\\!/]/
+
+const firstSegments = new Map<string, string>()
+
+/**
+ * The first path segment every path a glob (or its `asTrees` twin) can
+ * match starts with, or `ANYWHERE`. A task glob matches whole paths, so
+ * two globs with different first segments select disjoint sets, and none
+ * of `outputsOverlap`'s three cases can hold for them. Memoised by the
+ * raw string: a pure function, and one glob (`src/**`) recurs in every
+ * project.
+ */
+function firstSegment(raw: string): string {
+  let seg = firstSegments.get(raw)
+  if (seg !== undefined) return seg
+  const g = normalizeGlob(raw)
+  const cut = g.search(FIRST_SEGMENT_END)
+  seg = cut === -1 ? g : g[cut] === '/' ? g.slice(0, cut) : ANYWHERE
+  if (seg === '.' || seg === '..') seg = ANYWHERE
+  firstSegments.set(raw, seg)
+  return seg
+}
+
+/**
+ * False only when no pair `overlapCandidates` could return can overlap:
+ * every glob starts in a named segment and no two members (on different
+ * sides, given `sideOf`) share one. The per-project buckets are nearly
+ * all of this shape (`src/**` read, `dist/**` written), and building the
+ * indexes for each cost the warm run's graph stage tens of milliseconds
+ * at 1,090 projects (X-148).
+ */
+function mayOverlap<T>(
+  tasks: readonly T[],
+  globsOf: (n: T) => readonly string[] | undefined,
+  sideOf?: (n: T) => boolean,
+): boolean {
+  // Per segment: the first member seen (one side) or the sides seen as a mask.
+  const seen = new Map<string, number>()
+  for (let i = 0; i < tasks.length; i++) {
+    const mark = sideOf === undefined ? i : sideOf(tasks[i]!) ? 2 : 1
+    for (const g of globsOf(tasks[i]!) ?? []) {
+      const seg = firstSegment(g)
+      if (seg === ANYWHERE) return true
+      const was = seen.get(seg)
+      if (was === undefined) seen.set(seg, mark)
+      else if (sideOf === undefined) {
+        if (was !== i) return true
+      } else if ((was | mark) === 3) return true
+      else seen.set(seg, was | mark)
+    }
+  }
+  return false
+}
+
 /**
  * The pairs `[i, j]`, `i < j`, of `tasks` whose declared outputs CAN
  * overlap, ascending by `i` then `j`: a superset of the pairs
@@ -1181,6 +1240,7 @@ function overlapCandidates<T>(
   globsOf: (n: T) => readonly string[] | undefined,
   sideOf?: (n: T) => boolean,
 ): Array<[number, number]> {
+  if (!mayOverlap(tasks, globsOf, sideOf)) return []
   const sides = sideOf === undefined ? 1 : 2
   // The index a member of side `s` looks up: its own side's, or the other's.
   const across = (s: number): number => (sides === 1 ? s : 1 - s)
@@ -1356,6 +1416,7 @@ function refuseSelfClean(node: TaskNode): void {
   const cache = node.config.cache
   if (cache === undefined) return
   for (const field of ['files', 'workspaceFiles'] as const) {
+    if (!coversAny(cache.inputs[field], cache.outputs[field])) continue
     const inputs = splitNegations(cache.inputs[field] ?? [])
     const out = splitNegations(cache.outputs[field] ?? [])
     const outputs = out.positive
@@ -1384,6 +1445,39 @@ function refuseSelfClean(node: TaskNode): void {
   }
 }
 
+/**
+ * False only when no positive output can cover a positive input: each
+ * starts in a named first segment and no input shares one with an output
+ * (`firstSegment`). The common task reads `src/**` and writes `dist/**`.
+ */
+function coversAny(
+  inputs: readonly string[] | undefined,
+  outputs: readonly string[] | undefined,
+): boolean {
+  if (inputs === undefined || outputs === undefined) return false
+  let anyOutput = false
+  for (const go of outputs) {
+    if (go.startsWith('!')) continue
+    anyOutput = true
+    if (firstSegment(go) === ANYWHERE) return true
+  }
+  if (!anyOutput) return false
+  for (const gi of inputs) {
+    if (gi.startsWith('!')) continue
+    const seg = firstSegment(gi)
+    if (seg === ANYWHERE) return true
+    for (const go of outputs) if (!go.startsWith('!') && firstSegment(go) === seg) return true
+  }
+  return false
+}
+
+/** A glob list's positive entries: the list itself when it takes nothing back. */
+function positives(globs: readonly string[] | undefined): readonly string[] {
+  if (globs === undefined) return []
+  for (const g of globs) if (g.startsWith('!')) return splitNegations(globs).positive
+  return globs
+}
+
 /** One task's inputs (`reads`) or outputs in one namespace, for `detectInputOverlaps`. */
 interface Side {
   node: TaskNode
@@ -1431,8 +1525,8 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
   for (const n of nodes.values()) {
     const cache = n.config.cache
     if (cache === undefined) continue
-    const outFiles = splitNegations(cache.outputs.files).positive
-    const outWs = splitNegations(cache.outputs.workspaceFiles ?? []).positive
+    const outFiles = positives(cache.outputs.files)
+    const outWs = positives(cache.outputs.workspaceFiles ?? [])
     if (outFiles.length > 0) {
       bucket(n.projectName).push({ node: n, globs: outFiles, reads: false })
       filesWriters.push(n)
@@ -1443,8 +1537,8 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
       wsWriters.push(side)
     }
     if (isGroupTask(n)) continue
-    const inFiles = splitNegations(cache.inputs.files).positive
-    const inWs = splitNegations(cache.inputs.workspaceFiles ?? []).positive
+    const inFiles = positives(cache.inputs.files)
+    const inWs = positives(cache.inputs.workspaceFiles ?? [])
     if (inFiles.length > 0) {
       bucket(n.projectName).push({ node: n, globs: inFiles, reads: true })
       filesReaders.push(n)
@@ -1471,7 +1565,7 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
     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) =>
+      const globs = positives(node.config.cache!.inputs.files).map((g) =>
         rel === '' ? g : `${rel}/${g}`,
       )
       sides.push({ node, globs, reads: true, rel })
@@ -1488,7 +1582,7 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
   if (workspaceRoot !== undefined) {
     for (const node of filesWriters) {
       const rel = relPosix(workspaceRoot, node.projectDir)
-      const globs = splitNegations(node.config.cache!.outputs.files).positive.map((g) =>
+      const globs = positives(node.config.cache!.outputs.files).map((g) =>
         rel === '' ? g : `${rel}/${g}`,
       )
       rooted.push({ node, globs, reads: false, rel })

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. */