@vzn/vx 0.0.644 → 0.0.645

package/src/cache/layered-cache.ts

@@ -36,7 +36,6 @@ import type {
 } from './cache.js'
 import type { OutputDirRow } from './cache.js'
 import { RemoteLane, type ResolvedRemote } from './remote-lane.js'
-import type { BranchScope } from './scoped-cache.js'
 import type { PluginSecrets } from '../util/index.js'
 
 const STOPPED: unique symbol = Symbol('stopped')
@@ -46,7 +45,11 @@ const STOPPED: unique symbol = Symbol('stopped')
  * fails at once, removes its temp, and releases the connection; the cache
  * then closes under no write.
  */
-function endsOnStop(body: Blob | Response, stopped: Promise<typeof STOPPED>): Blob | Response {
+function endsOnStop(
+  body: Blob | Response,
+  stopped: Promise<typeof STOPPED>,
+  onChunk: (bytes: number) => void = () => {},
+): Blob | Response {
   if (body instanceof Blob || body.body === null) return body
   const reader = body.body.getReader()
   let stop = false
@@ -61,13 +64,28 @@ function endsOnStop(body: Blob | Response, stopped: Promise<typeof STOPPED>): Bl
       const next = await reader.read()
       if (stop) controller.error(new Error('the run was stopped'))
       else if (next.done) controller.close()
-      else controller.enqueue(next.value)
+      else {
+        onChunk(next.value.byteLength)
+        controller.enqueue(next.value)
+      }
     },
     cancel: (reason) => reader.cancel(reason),
   })
   return new Response(stream, { headers: body.headers })
 }
 
+const judged = (i: ArtifactInfo): i is { size: number; durationMs: number } =>
+  i.size !== undefined && i.durationMs !== undefined
+
+/** How often a task waiting on its download weighs running instead. */
+const JUDGE_EVERY_MS = 25
+
+interface Download {
+  readonly start: number
+  received: number
+  abandon(): void
+}
+
 /** What a remote's `open` is handed: the run's CI verdict and its plugin's keychain. */
 export interface RemoteOpenContext extends PluginSecrets {
   /** The run is on CI: nobody may be asked. */
@@ -77,13 +95,13 @@ export interface RemoteOpenContext extends PluginSecrets {
 }
 
 /**
- * Where a remote call's key lives: `scope` names the branch scope a scoped
- * key was derived in (`scopedKey`), absent for a task's own key. The key
- * alone is enough; a backend that keeps one store per scope may use it to
- * go straight to that store. turboCache(), nxCache() and vx-reapi ignore it.
+ * What a remote knows of an artifact it holds, before it is downloaded:
+ * the body's size in bytes and the producing task's duration, each when
+ * the wire carries it (Turbo's batch query and `HEAD` do).
  */
-export interface RemoteKey {
-  readonly scope?: string
+export interface ArtifactInfo {
+  readonly size?: number
+  readonly durationMs?: number
 }
 
 /**
@@ -122,17 +140,21 @@ export interface RemoteCacheLayer {
    * plugin's keychain and may ask on the terminal.
    */
   open?(ctx: RemoteOpenContext): Promise<void>
-  /** Existence probe: `--dry` and `--force` ask it per key when the remote cannot batch. */
-  has(hash: string, at?: RemoteKey): Promise<boolean>
   /**
-   * Optional batch existence probe: given N hashes, return the subset stored
-   * remotely in ONE round-trip. Its presence says the wire can batch: a run
-   * asks it once for its keys, `--dry` before its per-key answers, and
-   * `--force` in the background to skip uploads of held keys. Without it a
-   * run GETs each key directly (no `has`). Never throws for control flow:
-   * `null` means "no batch info; use per-hash". `at[i]` is `hashes[i]`'s.
+   * Existence probe: what the remote knows of the stored artifact, or null
+   * when it holds none. `--dry` and `--force` ask it per key when the
+   * remote cannot batch.
    */
-  hasMany?(hashes: readonly string[], at?: readonly RemoteKey[]): Promise<Set<string> | null>
+  has(hash: string): Promise<ArtifactInfo | null>
+  /**
+   * Optional batch existence probe: given N hashes, the stored ones and what
+   * the remote knows of each, in ONE round-trip. Its presence says the wire
+   * can batch: a run asks it once for its keys, `--dry` before its per-key
+   * answers, and `--force` in the background to skip uploads of held keys.
+   * Without it a run GETs each key directly (no `has`). Never throws for
+   * control flow: `null` means "no batch info; use per-hash".
+   */
+  hasMany?(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null>
   /**
    * Fetch an artifact; `null` = miss. `body` is read once, by core,
    * straight into the local cache — an HTTP wire returns its `fetch`
@@ -142,10 +164,7 @@ export interface RemoteCacheLayer {
    * nothing and the read is a miss, so a layer can check bytes as they pass
    * (a digest, a signature) and refuse at the end.
    */
-  get(
-    hash: string,
-    at?: RemoteKey,
-  ): Promise<{ body: Blob | Response; durationMs: number | undefined } | null>
+  get(hash: string): Promise<{ body: Blob | Response; durationMs: number | undefined } | null>
   /**
    * Store an artifact (fire-and-forget from LayeredCache's perspective).
    * `body` is file-backed (`Bun.file`) when the local store holds the
@@ -154,7 +173,7 @@ export interface RemoteCacheLayer {
    * key the remote holds keeps the stored bytes. Core never asks `has`
    * first; a wire that would overwrite checks inside.
    */
-  put(hash: string, body: Blob, meta: { durationMs: number } & RemoteKey): Promise<void>
+  put(hash: string, body: Blob, meta: { durationMs: number }): Promise<void>
 }
 
 export class LayeredCache implements CacheLayer {
@@ -196,23 +215,18 @@ export class LayeredCache implements CacheLayer {
    * its download and ingest took.
    */
   private readonly remoteSourced = new Map<string, number>()
+  /** What the batch probe said of each held key: its size and stored duration. */
+  private readonly infos = new Map<string, ArtifactInfo>()
+  /** Bodies being read now, by key: how far along, and how to give one up. */
+  private readonly downloads = new Map<string, Download>()
 
   /** Remotes in declared order: the first readable one holding a hash answers it. */
   constructor(
     readonly local: Cache,
     remotes: readonly ResolvedRemote[],
-    /** The run's branch scope: it picks each remote key; the local store never sees it. */
-    private readonly branch?: BranchScope,
     uploadConcurrency?: number,
   ) {
-    this.lanes = remotes.map(
-      (r) =>
-        new RemoteLane(r, local.traffic, branch?.remote(r.remote) ?? r.remote, uploadConcurrency),
-    )
-  }
-
-  noteKey(taskId: string, hash: string): void {
-    this.branch?.noteKey(taskId, hash)
+    this.lanes = remotes.map((r) => new RemoteLane(r, local.traffic, uploadConcurrency))
   }
 
   // Asked, not kept: a remote whose `open` failed leaves the run after this is built.
@@ -249,9 +263,12 @@ export class LayeredCache implements CacheLayer {
    * absences either way, so a hash only a sibling holds costs it no GET.
    * Never throws.
    */
-  async remoteHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
+  async remoteHasMany(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null> {
     if (this.readable.length === 0) return null
-    const answer = this.probeMany(hashes)
+    const answer = this.probeMany(hashes).then((found) => {
+      if (found !== null) for (const [h, info] of found) this.infos.set(h, info)
+      return found
+    })
     const waiting = hashes.filter((h) => !this.inflight.has(h) && !this.probing.has(h))
     for (const h of waiting) {
       this.probing.set(
@@ -271,12 +288,12 @@ export class LayeredCache implements CacheLayer {
     return answer
   }
 
-  private async probeMany(hashes: readonly string[]): Promise<Set<string> | null> {
-    let out: Set<string> | null = new Set()
+  private async probeMany(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null> {
+    let out: Map<string, ArtifactInfo> | null = new Map()
     for (const lane of this.readable) {
       const found = await lane.hasMany(hashes)
       if (found === null) out = null
-      else if (out !== null) for (const h of found) out.add(h)
+      else if (out !== null) for (const [h, info] of found) if (!out.has(h)) out.set(h, info)
     }
     return out
   }
@@ -328,7 +345,7 @@ export class LayeredCache implements CacheLayer {
     // remote walk per key: a settled `false` means no remote had it
     // (no second probe), and a settled/in-flight `true` means the
     // artifact was/will-be ingested locally — re-read below.
-    const ingested = await this.pullFromRemote(hash, ctx)
+    const ingested = await this.awaitOrRun(hash, this.pullFromRemote(hash, ctx))
     if (!ingested) return null
 
     // Read past the local READ gate: `ingest` is deliberately ungated, so
@@ -350,6 +367,39 @@ export class LayeredCache implements CacheLayer {
     return this.asRemote(hash, materialized)
   }
 
+  /**
+   * A pull the task now waits on, given up when the rest of its body would
+   * take longer than running the task (its stored duration, doubled for
+   * the save a run adds): the task then runs here, a miss. Only a key the
+   * batch probe sized and timed is judged, from its own body's pace so far.
+   * The facts are read each tick: the probe can answer after the task asks.
+   */
+  private async awaitOrRun(hash: string, pull: Promise<boolean>): Promise<boolean> {
+    if (this.infos.has(hash) && !judged(this.infos.get(hash)!)) return pull
+    for (;;) {
+      const done = await Promise.race([pull, Bun.sleep(JUDGE_EVERY_MS).then(() => undefined)])
+      if (done !== undefined) return done
+      const info = this.infos.get(hash)
+      if (info === undefined) continue
+      if (!judged(info)) return pull
+      const budget = info.durationMs * 2
+      const dl = this.downloads.get(hash)
+      if (dl === undefined) continue
+      const elapsed = performance.now() - dl.start
+      const left =
+        dl.received === 0
+          ? elapsed > budget
+            ? Infinity
+            : 0
+          : ((info.size - dl.received) * elapsed) / dl.received
+      if (left > budget) {
+        dl.abandon()
+        await pull
+        return false
+      }
+    }
+  }
+
   private asRemote(hash: string, entry: CacheEntry): CacheEntry {
     const fetchMs = this.remoteSourced.get(hash)
     return fetchMs === undefined ? entry : { ...entry, source: 'remote', fetchMs }
@@ -360,7 +410,7 @@ export class LayeredCache implements CacheLayer {
   // a remote cache. Remote errors degrade to a miss (never throw).
   async has(hash: string): Promise<'local' | 'remote' | null> {
     if ((await this.local.has(hash)) === 'local') return 'local'
-    for (const lane of this.readable) if (await lane.has(hash)) return 'remote'
+    for (const lane of this.readable) if ((await lane.has(hash)) !== null) return 'remote'
     return null
   }
 
@@ -434,10 +484,19 @@ export class LayeredCache implements CacheLayer {
       durationMs: durationOf(remoteBody.durationMs),
       ...(ctx?.outputs !== undefined ? { outputs: ctx.outputs } : {}),
     }
+    let abandon = (): void => {}
+    const abandoned = new Promise<typeof STOPPED>((resolve) => (abandon = () => resolve(STOPPED)))
+    const dl: Download = { start: performance.now(), received: 0, abandon }
+    this.downloads.set(hash, dl)
+    const ends = Promise.race([stopped, abandoned])
     try {
-      const ingest = this.local.ingest(hash, endsOnStop(remoteBody.body, stopped), meta)
+      const ingest = this.local.ingest(
+        hash,
+        endsOnStop(remoteBody.body, ends, (n) => (dl.received += n)),
+        meta,
+      )
       ingest.catch(() => undefined)
-      if ((await Promise.race([ingest, stopped])) === STOPPED) return false
+      if ((await Promise.race([ingest, ends])) === STOPPED) return false
     } catch (err) {
       // The bytes came off the network — a corrupt/truncated remote
       // artifact must degrade to a cache miss (task re-executes), not
@@ -445,8 +504,13 @@ export class LayeredCache implements CacheLayer {
       // down: `Cache.restoreOutputs` drops it (A-52).
       lane.report('download', hash, err)
       return false
+    } finally {
+      this.downloads.delete(hash)
     }
     this.remoteSourced.set(hash, Math.round(performance.now() - fetchStart))
+    this.local.downloads.count++
+    this.local.downloads.bytes +=
+      remoteBody.body instanceof Blob ? remoteBody.body.size : dl.received
     return true
   }
 

package/src/cache/plugin-cache.ts

@@ -8,7 +8,6 @@
 
 import type { Database } from 'bun:sqlite'
 import { xxh3hex } from '../util/index.js'
-import type { RemoteKey } from './layered-cache.js'
 import type { CachePolicy } from './policy.js'
 import type { ResolvedRemote } from './remote-lane.js'
 import { scopedKey } from './scoped-cache.js'
@@ -100,8 +99,6 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
   const { db, policy, scope } = host
   const readers = host.remotes.filter((r) => r.read)
   const writers = host.remotes.filter((r) => r.write)
-  const at: RemoteKey = scope === undefined ? {} : { scope }
-  const atOf = (key: string, name: string): RemoteKey => (key === entryKey(plugin, name) ? {} : at)
   const readKey = (name: string, scoped: boolean): string => {
     const key = entryKey(plugin, name)
     return scope === undefined || !scoped ? key : scopedKey(scope, key)
@@ -155,7 +152,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       const key = readKey(name, scoped)
       for (const { remote } of readers) {
         try {
-          const got = await remote.get(key, atOf(key, name))
+          const got = await remote.get(key)
           if (got === null) continue
           const bytes = await capped(got.body)
           if (bytes === null) continue
@@ -174,7 +171,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       if (policy.localWrite) localPut(entryKey(plugin, name), bytes)
       for (const { remote } of writers) {
         try {
-          await remote.put(key, new Blob([bytes]), { durationMs: 0, ...at })
+          await remote.put(key, new Blob([bytes]), { durationMs: 0 })
         } catch {
           // the other layers still keep it
         }
@@ -187,7 +184,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       let answered = policy.localRead
       for (const { remote } of readers) {
         try {
-          if (await remote.has(key, atOf(key, name))) return true
+          if (await remote.has(key)) return true
           answered = true
         } catch {
           // no answer from this remote
@@ -207,12 +204,10 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         if (ask.length === 0) break
         if (remote.hasMany === undefined) return null
         try {
-          const got: unknown = await remote.hasMany(
-            ask,
-            ask.map((k) => atOf(k, byKey.get(k)!)),
-          )
-          if (!(got instanceof Set)) return null
-          for (const key of got) if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
+          const got: unknown = await remote.hasMany(ask)
+          if (!(got instanceof Map)) return null
+          for (const key of got.keys())
+            if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
         } catch {
           return null
         }
@@ -222,9 +217,9 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
 
     async getRun(name) {
       for (const { remote } of readers) {
-        for (const [i, key] of runReadKeys(name, scope).entries()) {
+        for (const key of runReadKeys(name, scope)) {
           try {
-            const got = await remote.get(key, i === 0 ? {} : at)
+            const got = await remote.get(key)
             if (got === null) continue
             const bytes = await capped(got.body, Infinity)
             if (bytes !== null) return bytes

package/src/cache/remote-lane.ts

@@ -6,7 +6,7 @@
 
 import { machineParallelism } from '../util/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
-import type { RemoteCacheLayer } from './layered-cache.js'
+import type { ArtifactInfo, RemoteCacheLayer } from './layered-cache.js'
 
 /** One remote, resolved: its wire and what the run's policy and its `access` let it do. */
 export interface ResolvedRemote {
@@ -48,6 +48,14 @@ function invalidRemoteResult(what: string): Error {
   )
 }
 
+/** A plugin's `ArtifactInfo`, keeping only the fields that are finite, non-negative numbers; null when it is no object. */
+function artifactInfo(value: unknown): ArtifactInfo | null {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
+  const { size, durationMs } = value as Record<string, unknown>
+  const ok = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n) && n >= 0
+  return { ...(ok(size) ? { size } : {}), ...(ok(durationMs) ? { durationMs } : {}) }
+}
+
 function isBody(value: unknown): value is Blob | Response {
   return value instanceof Blob || value instanceof Response
 }
@@ -106,14 +114,16 @@ export class RemoteLane {
    */
   private readonly absent = new Set<string>()
   /** What a `hasMany` said this remote holds, as `absent` records the rest. */
-  private readonly held = new Set<string>()
+  private readonly held = new Map<string, ArtifactInfo>()
 
   /**
    * A remote the run writes but does not read (`--force`): which of the
    * run's up-front keys it already holds, from one `hasMany`. `found` is
    * null when the probe failed.
    */
-  private presence: Promise<{ asked: Set<string>; found: Set<string> | null } | null> | undefined
+  private presence:
+    | Promise<{ asked: Set<string>; found: Map<string, ArtifactInfo> | null } | null>
+    | undefined
 
   private readonly uploadQueue: Array<() => Promise<void>> = []
   private activeUploads = 0
@@ -136,13 +146,11 @@ export class RemoteLane {
   constructor(
     resolved: ResolvedRemote,
     private readonly traffic: RemoteTraffic,
-    /** The wire as this run asks it: a branch scope's view of `resolved.remote`. */
-    remote: RemoteCacheLayer = resolved.remote,
     /** Background PUTs at once; excess uploads queue and drain FIFO. */
     private readonly uploadConcurrency: number = networkConcurrency(),
   ) {
     this.resolved = resolved
-    this.remote = remote
+    this.remote = resolved.remote
     this.onError = resolved.onError
     this.endpoint = printableEndpoint(resolved.remote.endpoint)
   }
@@ -159,15 +167,28 @@ export class RemoteLane {
    * Existence probe; a failure is a miss. A key a `hasMany` this run
    * answered for is not asked again: `--dry` batches its keys first.
    */
-  async has(hash: string): Promise<boolean> {
-    if (this.held.has(hash)) return true
-    if (this.absent.has(hash)) return false
+  async has(hash: string): Promise<ArtifactInfo | null> {
+    const held = this.held.get(hash)
+    if (held !== undefined) return held
+    if (this.absent.has(hash)) return null
+    let found: unknown
     try {
-      return Boolean(await this.remote.has(hash))
+      found = await this.remote.has(hash)
     } catch (err) {
       this.report('probe', hash, err)
-      return false
+      return null
     }
+    if (found === null || found === undefined) return null
+    const info = artifactInfo(found)
+    if (info === null)
+      this.report(
+        'probe',
+        hash,
+        invalidRemoteResult(
+          `has() resolved ${describeValue(found)} (expected { size, durationMs } or null)`,
+        ),
+      )
+    return info
   }
 
   /**
@@ -175,7 +196,7 @@ export class RemoteLane {
    * rest as absent; `null` when this remote cannot batch or the probe
    * failed, which the caller reads as "no batch info".
    */
-  async hasMany(hashes: readonly string[]): Promise<Set<string> | null> {
+  async hasMany(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null> {
     if (this.remote.hasMany === undefined) return null
     let found: unknown
     try {
@@ -185,19 +206,26 @@ export class RemoteLane {
       return null
     }
     if (found === null || found === undefined) return null
-    if (!(found instanceof Set)) {
+    if (!(found instanceof Map)) {
       this.report(
         'probe',
         batchOf(hashes),
         invalidRemoteResult(
-          `hasMany() resolved ${describeValue(found)} (expected a Set of the hashes present, or null)`,
+          `hasMany() resolved ${describeValue(found)} (expected a Map of the hashes present, or null)`,
         ),
       )
       return null
     }
-    const set = found as Set<string>
-    for (const h of hashes) (set.has(h) ? this.held : this.absent).add(h)
-    return set
+    const out = new Map<string, ArtifactInfo>()
+    for (const h of hashes) {
+      const info = found.has(h) ? (artifactInfo(found.get(h)) ?? {}) : undefined
+      if (info === undefined) this.absent.add(h)
+      else {
+        this.held.set(h, info)
+        out.set(h, info)
+      }
+    }
+    return out
   }
 
   /** The artifact's body, or null on a miss, a known absence, a failure or a malformed answer. */
@@ -253,7 +281,7 @@ export class RemoteLane {
     const probed = await this.presence
     if (probed !== undefined && probed !== null && probed.found !== null && probed.asked.has(hash))
       return probed.found.has(hash)
-    return this.has(hash)
+    return (await this.has(hash)) !== null
   }
 
   /** Queue a PUT in this remote's bounded pool; `body` is asked for when the job starts. */
@@ -270,6 +298,7 @@ export class RemoteLane {
       let release: (() => Promise<void>) | undefined
       try {
         if (this.stopped) return
+        if (this.held.has(hash)) return
         if (!this.read && (await this.holds(hash))) return
         if (this.stopped) return
         const start = performance.now()

package/src/cache/scoped-cache.ts

@@ -1,87 +1,10 @@
-// A branch's cache scope (owner, 2026-10-17): the local store never knows
-// one, so every branch shares one local pool under the task keys. Scopes
-// decide only which remote entry a task asks for: a task the branch changed
-// reads the scope's key, every other task the default key, and a scoped run
-// writes every remote under the scope's key. An artifact is packed under its
-// task key wherever it is stored, so a remote entry ingests under that key.
+// A scope keys only what plugins store themselves (ctx.cache, run records):
+// task keys reach every remote plain, and a remote decides which branch a
+// read may see (VZN, 2026-10-20).
 
 import { xxh3hex } from '../util/index.js'
-import type { RemoteCacheLayer, RemoteKey } from './layered-cache.js'
 
 /** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
 export function scopedKey(scope: string, hash: string): string {
   return xxh3hex(`vx-cache-scope\0${scope}\0${hash}`)
 }
-
-/**
- * Which remote key each task asks for, in a run with a scope. The routes
- * come from the branch's diff, which only a remote call awaits: a run the
- * local cache answers never waits on git.
- */
-export class BranchScope {
-  /** Finds the tasks that read the scope, at the first remote call; null: every task does. */
-  private route: (() => Promise<ReadonlySet<string>>) | null = null
-  private routes: Promise<ReadonlySet<string>> | null = null
-  /** Task key → its task. */
-  private readonly taskOf = new Map<string, string>()
-
-  constructor(readonly scope: string) {}
-
-  /** Only the tasks `ids` finds read the scope; set before any remote call. */
-  routeTasks(ids: () => Promise<ReadonlySet<string>>): void {
-    this.route = ids
-  }
-
-  noteKey(taskId: string, hash: string): void {
-    this.taskOf.set(hash, taskId)
-  }
-
-  /** The remote key `hash` is read under, and the scope it is read in (none: the default key). */
-  private async readKey(hash: string): Promise<{ key: string; at: RemoteKey }> {
-    const id = this.taskOf.get(hash)
-    if (this.route !== null) this.routes ??= this.route()
-    const tasks = this.routes === null ? null : await this.routes
-    return tasks !== null && id !== undefined && !tasks.has(id)
-      ? { key: hash, at: {} }
-      : { key: scopedKey(this.scope, hash), at: { scope: this.scope } }
-  }
-
-  /**
-   * `inner` as this run asks it: each task key under its route's key; every
-   * write under the scope's. Each call also names its scope, for a backend
-   * that keeps one store per scope; no wire vx ships sends it.
-   */
-  remote(inner: RemoteCacheLayer): RemoteCacheLayer {
-    const read = (h: string) => this.readKey(h)
-    const at: RemoteKey = { scope: this.scope }
-    const hasMany = inner.hasMany
-    return {
-      ...(inner.endpoint !== undefined ? { endpoint: inner.endpoint } : {}),
-      ...(inner.open !== undefined ? { open: (ctx) => inner.open!(ctx) } : {}),
-      has: async (h) => {
-        const r = await read(h)
-        return inner.has(r.key, r.at)
-      },
-      ...(hasMany !== undefined
-        ? {
-            hasMany: async (hashes) => {
-              const reads = await Promise.all(hashes.map(read))
-              const keys = reads.map((r) => r.key)
-              const found = await hasMany.call(
-                inner,
-                keys,
-                reads.map((r) => r.at),
-              )
-              if (!(found instanceof Set)) return found
-              return new Set(hashes.filter((_, i) => found.has(keys[i]!)))
-            },
-          }
-        : {}),
-      get: async (h) => {
-        const r = await read(h)
-        return inner.get(r.key, r.at)
-      },
-      put: (h, body, meta) => inner.put(scopedKey(this.scope, h), body, { ...meta, ...at }),
-    }
-  }
-}

package/src/cli/help.ts

@@ -264,10 +264,10 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '      --cache-dir <path>  Read the cache a run with the same flag uses.',
     '',
     'Migration:',
-    '  vx init              With no package.json: write .vx/workspace.ts and an empty',
-    '                       root vx.config.ts. With one: runs @vzn/vx-migrate, which maps',
-    '                       turbo.json, an Nx graph or package.json scripts to one',
-    '                       vx.config.ts per package (asking native or keep in Turbo/Nx).',
+    '  vx init              Install vx globally and as the root devDependency, then',
+    '                       write .vx/workspace.ts and an empty root vx.config.ts. In a',
+    '                       Turbo or Nx repo: runs @vzn/vx-migrate, which maps turbo.json',
+    '                       or the Nx graph to vx (asking native or keep).',
     '      --dry            Print the generated files instead of writing them.',
     '      --format json    With --dry: the plan as one JSON document (schemas/init.json).',
     '      --force          Overwrite existing vx.config.* files.',