@vzn/vx 0.0.638 → 0.0.639

package/src/cache/cache.ts

@@ -96,6 +96,7 @@ import {
   type PruneResult,
   type RunRecord,
   type SaveArgs,
+  type TaskInputComponent,
   type TaskInputRow,
   WORKSPACE_OUTPUT_PREFIX,
 } from './layer.js'
@@ -309,17 +310,19 @@ function outOfFdsAtOpen(dbFile: string, err: unknown): UserError | undefined {
 //   v38: blob_sizes moved to the store, and the store's task_outcomes
 //        holds the flaky record, so worktrees share both. The cache KEY is
 //        unchanged.
-export const SCHEMA_VERSION = 'v38'
+//   v39: invocations drops `tags` (`--tag` is gone). The cache KEY is
+//        unchanged.
+//   v40: runs.remote_error — each remote read or write of a task's key that
+//        failed, for `vx last`. The cache KEY is unchanged.
+export const SCHEMA_VERSION = 'v40'
 
 /**
  * An entry's key components as its one `entry_inputs` row (v34): JSON
  * `[kind, name, hash]` triples in (kind, name) code-unit order, the first
  * of a repeated (kind, name) kept, as the per-component primary key did.
  */
-function encodeEntryInputs(
-  components: readonly Pick<TaskInputRow, 'kind' | 'name' | 'hash'>[],
-): string {
-  const byId = new Map<string, Pick<TaskInputRow, 'kind' | 'name' | 'hash'>>()
+function encodeEntryInputs(components: readonly TaskInputComponent[]): string {
+  const byId = new Map<string, TaskInputComponent>()
   for (const c of components) {
     const id = `${c.kind}\0${c.name}`
     if (!byId.has(id)) byId.set(id, c)
@@ -788,6 +791,23 @@ export interface UploadTally {
   failed: number
 }
 
+/** One task's traffic with the remotes this run, by its key. */
+export interface RemoteKeyTraffic {
+  /** Its uploads queued or running. */
+  uploading: number
+  /** An upload of it landed on a remote. */
+  landed: boolean
+  /** Each distinct remote read or write of it that failed: `upload: <message>`. */
+  failures: string[]
+}
+
+/** The run's remote traffic per key: what the footer's remote part counts, task by task. */
+export interface RemoteTraffic {
+  /** Uploads queued or running across every remote. */
+  inFlight: number
+  readonly keys: Map<string, RemoteKeyTraffic>
+}
+
 export class Cache implements CacheLayer {
   /** This IS the local layer — there is nothing slower behind it. */
   readonly hasRemote = false
@@ -797,6 +817,8 @@ export class Cache implements CacheLayer {
    * so the run can report them without a method on the layer seam.
    */
   readonly uploads: UploadTally = { count: 0, bytes: 0, ms: 0, failed: 0 }
+  /** The same remotes' traffic per key, filled by the same `LayeredCache`. */
+  readonly traffic: RemoteTraffic = { inFlight: 0, keys: new Map() }
 
   private readonly db: Database
   private readonly insertEntry: ReturnType<Database['prepare']>
@@ -1758,9 +1780,14 @@ export class Cache implements CacheLayer {
 
   private async hasEntry(hash: string): Promise<'local' | 'remote' | null> {
     if (!this.read) return null
+    return this.storedHere(hash) ? 'local' : null
+  }
+
+  /** The index row and its artifact are both here, whatever the run may read. */
+  private storedHere(hash: string): boolean {
     const row = this.entryExists.get(hash) as { inline_at: number | null } | null
-    if (row === null) return null
-    return row.inline_at !== null || existsSync(this.tarPath(hash)) ? 'local' : null
+    if (row === null) return false
+    return row.inline_at !== null || existsSync(this.tarPath(hash))
   }
 
   // Local cache has no slower layer to warm from — prefetch is a no-op.
@@ -2054,8 +2081,6 @@ export class Cache implements CacheLayer {
     entry: Omit<CacheEntry, 'hash' | 'storedAt' | 'outputFiles' | 'exitCode'>
     projectDir: string
     outputFiles: string[]
-    /** See `CacheLayer.save`. */
-    skipLocalWrite?: boolean
     workspaceOutputFiles?: string[]
     workspaceRoot?: string
     inputComponents?: readonly TaskInputRow[]
@@ -2080,7 +2105,9 @@ export class Cache implements CacheLayer {
     // still uploads to remote — it calls `packArtifact` itself to get
     // the bytes, since there's no local artifact to read off disk.
     if (!this.write) return
-    if (args.skipLocalWrite === true) return
+    // A cache that reads saves only on a miss. One that does not (`--force`)
+    // re-executes a key it may hold: that entry is kept as it is.
+    if (!this.read && this.guard(() => this.storedHere(args.hash))) return
     // The cache directory is the constructor's (`mkdirSync`, with a
     // refusal recorded for `assertWritable`); re-creating it here and
     // again in `writeArtifactAndIndex` cost every save two thread-pool
@@ -2631,6 +2658,9 @@ export class Cache implements CacheLayer {
   recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
     return this.guard(() => this.history.recordRunBundle(bundle))
   }
+  recordRemoteErrors(runId: string, errors: readonly (readonly [string, string])[]): void {
+    return this.guard(() => this.history.recordRemoteErrors(runId, errors))
+  }
   stats(opts: CacheStatsOptions = {}): CacheStats {
     return this.guard(() => this.statsOf(opts))
   }

package/src/cache/git-inputs.ts

@@ -289,6 +289,12 @@ export class GitFilesCache extends Map<string, readonly string[]> {
    * a cache no enumeration filled; its OIDs are then re-checked by content.
    */
   enumeratedAtMs: number | undefined
+  /**
+   * The declared outputs (root-relative globs) git ignores whole, asked
+   * once per run beside the enumeration: no key reads them, so a reader
+   * beside their producer keys up front (`dependsOnSiblingOutputs`).
+   */
+  ignoredOutputs: ReadonlySet<string> = new Set()
 
   get undecodableNames(): ReadonlySet<string> {
     return this.undecodable

package/src/cache/index.ts

@@ -21,6 +21,7 @@ export {
   KEYED_RUNS_SQL,
   parseCachePolicy,
   type RunRecord,
+  type TaskInputComponent,
   type TaskInputRow,
   WORKSPACE_OUTPUT_PREFIX,
   type OutputDirRow,
@@ -69,14 +70,13 @@ export {
   type BlobSizeMemo,
 } from './git-inputs.js'
 export { LayeredCache, type RemoteCacheLayer } from './layered-cache.js'
+export type { ResolvedRemote } from './remote-lane.js'
 export { ScopedCache } from './scoped-cache.js'
 export {
   absentPluginCache,
   pluginCache,
   PLUGIN_ENTRY_MAX_BYTES,
   type PluginCache,
-  type PluginCacheRemote,
 } from './plugin-cache.js'
 export { packRunOutputs, putRunEntry, runEntryName, writesRunStore } from './run-store.js'
-export { ChainedCache } from './chained-cache.js'
 export { branchSource } from './run-history.js'

package/src/cache/layer.ts

@@ -1,5 +1,5 @@
 // The cache layer CONTRACT and its records — what every cache implementation
-// honours (`Cache`, `LayeredCache`, `ChainedCache`, a plugin's remote layer) and
+// honours (`Cache`, `LayeredCache`, a plugin's remote layer) and
 // the shapes that cross it: the key input, entries, run-history rows, output
 // fingerprints, stats, prune options. No implementation lives here; the one
 // reference to `Cache` below is a type (the local handle a layer may wrap).
@@ -208,6 +208,8 @@ export interface RunRecord {
   timedOut?: true
   sandboxViolations?: number
   notReady?: 'timeout' | 'exited' | 'spawn'
+  /** Each remote read or write of its key that failed, `upload: <message>`, `; `-joined (v40). */
+  remoteError?: string
 }
 
 /**
@@ -247,8 +249,18 @@ export interface InvocationRecord {
   os: string | null
   arch: string | null
   vxVersion: string
-  /** JSON object `{k:v}` of `--tag` pairs. */
-  tags: string
+}
+
+/**
+ * One cache-key component as `key()` folded it, the `captureInto` row.
+ * Persisted on a miss (`TaskInputRow`) so a later run can diff its inputs
+ * against this one (the Tier-3 "why did this re-run?" moat); a hit saves
+ * nothing, so the warm path is free.
+ */
+export interface TaskInputComponent {
+  kind: string
+  name: string
+  hash: string
 }
 
 /**
@@ -556,6 +568,13 @@ export interface CacheLayer {
    * no round-trip. Only meaningful with `hasRemote`.
    */
   markRemoteAbsent?(hashes: Iterable<string>): void
+  /**
+   * The run's up-front keys, for each remote the run writes but does not
+   * read (`--force`): one batch probe in the background, and an upload of
+   * a key the remote already holds is skipped. Only meaningful with
+   * `hasRemote`.
+   */
+  probeBeforeUpload?(hashes: Promise<readonly string[]>): void
   /**
    * Resolve once every background write-through upload settles. The
    * orchestrator awaits it before `close()` — an upload reading layer state
@@ -563,6 +582,8 @@ export interface CacheLayer {
    * uploads synchronously (or not at all) omits it.
    */
   drainUploads?(): Promise<void>
+  /** The run was stopped: start no more uploads, and let `drainUploads` resolve now. */
+  stopUploads?(): void
   key(input: CacheKeyInput): Promise<string>
   get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null>
   /**
@@ -580,7 +601,7 @@ export interface CacheLayer {
    * artifact read, no remote download, no local ingest, no accessed_at
    * bump (on the remote side the layer decides the call: an HTTP HEAD, or
    * REAPI's `getActionResult` + `findMissingBlobs`). Planning
-   * (`--dry` / `--graph`) predicts hits with this instead of `get` so a
+   * (`--dry`) predicts hits with this instead of `get` so a
    * dry run can't pull N artifacts over the network. Remote errors
    * degrade to `null` — an existence probe never fails anything.
    */
@@ -670,13 +691,6 @@ export interface CacheLayer {
     entry: Omit<CacheEntry, 'hash' | 'storedAt' | 'outputFiles' | 'exitCode'>
     projectDir: string
     outputFiles: string[]
-    /**
-     * Set only by ChainedCache when an EARLIER layer in the chain already
-     * wrote this artifact to the same local handle: the local pack + write
-     * is skipped and only the layer's remote side acts. A layer with no
-     * remote side treats it as a full no-op.
-     */
-    skipLocalWrite?: boolean
     /**
      * Resolved `outputs.workspaceFiles` (absolute paths) + the root
      * they're relative to. Packed under `workspace-outputs/<rel>`.