@vzn/vx 0.0.21 → 0.0.23

package/src/cache/chained-cache.ts

@@ -43,6 +43,15 @@ export class ChainedCache implements CacheLayer {
   }
 
   async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
+    // The layer that pulled this hash in a prefetch answers first. Layers
+    // may share one local store, and an earlier layer found the pulled copy
+    // there and called it a local hit: a second remote's hit was counted as
+    // saved locally, in the outcome, the summary and telemetry (item 889).
+    const owner = this.hitLayer.get(hash)
+    if (owner !== undefined) {
+      const entry = await owner.get(hash, ctx)
+      if (entry !== null) return entry
+    }
     for (const layer of this.layers) {
       const entry = await layer.get(hash, ctx)
       if (entry !== null) {
@@ -127,6 +136,9 @@ export class ChainedCache implements CacheLayer {
   recordOutputDirs(hash: string, projectDir: string, prefixes: readonly string[]): Promise<void> {
     return this.layers[0]!.recordOutputDirs?.(hash, projectDir, prefixes) ?? Promise.resolve()
   }
+  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
+    this.layers[0]!.recordOutputStamps?.(hash, projectDir, workspaceRoot)
+  }
 
   loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
     return this.layers[0]!.loadOutputDirsBatch?.(hashes) ?? new Map()
@@ -155,8 +167,8 @@ export class ChainedCache implements CacheLayer {
     }
   }
 
-  ingest(hash: string, compressed: Uint8Array, meta: IngestMeta): Promise<void> {
-    return this.layers[0]!.ingest(hash, compressed, meta)
+  ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void> {
+    return this.layers[0]!.ingest(hash, body, meta)
   }
 
   recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {

package/src/cache/config-evals.ts

@@ -8,6 +8,7 @@ import type { Database, SQLQueryBindings } from 'bun:sqlite'
 export class ConfigEvalTable {
   private readonly selectConfigEval: ReturnType<Database['prepare']>
   private readonly insertConfigEval: ReturnType<Database['prepare']>
+  private readonly upsertConfigClosure: ReturnType<Database['prepare']>
   private readonly read: boolean
   private readonly write: boolean
 
@@ -21,6 +22,9 @@ export class ConfigEvalTable {
     this.insertConfigEval = this.db.prepare(
       'INSERT OR REPLACE INTO config_evals(key, json, created_at) VALUES (?, ?, ?)',
     )
+    this.upsertConfigClosure = this.db.prepare(
+      'INSERT INTO config_closures(config_path, files_json, created_at) VALUES (?, ?, ?) ON CONFLICT(config_path) DO UPDATE SET files_json = excluded.files_json, created_at = excluded.created_at',
+    )
   }
 
   /** `ConfigEvalStore`: a cached config evaluation, honouring the local READ axis. */
@@ -52,11 +56,17 @@ export class ConfigEvalTable {
   /** `ConfigEvalStore`: remember a config's ordered closure, honouring the local WRITE axis. */
   putConfigClosure(configPath: string, files: readonly string[]): void {
     if (!this.write) return
-    this.db
-      .prepare(
-        'INSERT INTO config_closures(config_path, files_json, created_at) VALUES (?, ?, ?) ON CONFLICT(config_path) DO UPDATE SET files_json = excluded.files_json, created_at = excluded.created_at',
-      )
-      .run(configPath, JSON.stringify(files), Date.now())
+    this.upsertConfigClosure.run(configPath, JSON.stringify(files), Date.now())
+  }
+
+  /** `ConfigEvalStore`: a round's closures in ONE transaction (each upsert was its own, item 615). */
+  putConfigClosures(entries: ReadonlyArray<readonly [string, readonly string[]]>): void {
+    if (!this.write || entries.length === 0) return
+    const now = Date.now()
+    this.db.transaction(() => {
+      for (const [configPath, files] of entries)
+        this.upsertConfigClosure.run(configPath, JSON.stringify(files), now)
+    })()
   }
 
   /** `ConfigEvalStore`: the batched read — one `IN` query per 900 keys, honouring the local READ axis. */
@@ -81,7 +91,20 @@ export class ConfigEvalTable {
     this.insertConfigEval.run(key, json, Date.now())
   }
 
-  /** Retention: a config not loaded since `cutoff` was edited or its project left. */
+  /** `ConfigEvalStore`: a round's evaluations in ONE transaction. */
+  putConfigEvals(entries: ReadonlyArray<readonly [string, string]>): void {
+    if (!this.write || entries.length === 0) return
+    const now = Date.now()
+    this.db.transaction(() => {
+      for (const [key, json] of entries) this.insertConfigEval.run(key, json, now)
+    })()
+  }
+
+  /**
+   * Retention: a row not WRITTEN since `cutoff`. A hit does not refresh it
+   * (that would be a write per config on every warm run), so a config that
+   * hit for thirty days is evaluated once more and stored again.
+   */
   pruneOlderThan(cutoff: number): void {
     this.db.prepare('DELETE FROM config_evals WHERE created_at < ?').run(cutoff)
     this.db.prepare('DELETE FROM config_closures WHERE created_at < ?').run(cutoff)

package/src/cache/file-hashes.ts

@@ -7,8 +7,9 @@
 // the store's handle; `Cache` delegates.
 
 import type { Database } from 'bun:sqlite'
-import { lstatSync, readlinkSync, statSync } from 'node:fs'
+import { lstatSync, readlinkSync } from 'node:fs'
 import path from 'node:path'
+import { fileIdentity, repoFacts } from './git-inputs.js'
 import { FILE_HASH_RACY_MS } from './layer.js'
 
 export class FileHashStore {
@@ -18,8 +19,17 @@ export class FileHashStore {
 
   constructor(
     private readonly db: Database,
-    /** Where `git rev-parse --show-object-format` is asked, once, when a file misses the memo. */
+    /** Where the object format is asked when no `repoDir` is given and no file is named. */
     private readonly cacheDir: string,
+    /** The local WRITE axis: off, and a miss is hashed but not remembered (a read-only cache). */
+    private readonly write: boolean = true,
+    /**
+     * The directory whose repository answers the object format — the
+     * workspace root, in a run: the enumeration asks git there too, and
+     * `repoFacts` answers both from one spawn. Absent, the directory of the
+     * first file hashed answers.
+     */
+    private readonly repoDir?: string,
   ) {
     this.selectFileHash = this.db.prepare(
       'SELECT mtime_ms, size_bytes, ctime_ms, ino, content_hash FROM file_hashes WHERE path = ?',
@@ -50,7 +60,7 @@ export class FileHashStore {
    * mode-120000 blob of the link text — so this fallback and the
    * `CacheKeyInput.fileHashes` index-OID fast path agree on any file
    * git stores verbatim. They do NOT agree when a clean filter
-   * (`text`/`eol`/`ident`) is active: the index blob is the filtered
+   * (`text`/`eol`/`ident`/`filter`/`working-tree-encoding`) is active: the index blob is the filtered
    * form while this hashes the worktree bytes, so `inputs.ts` drops
    * the index OID for those paths and routes them here.
    */
@@ -74,11 +84,19 @@ export class FileHashStore {
     // is its mode-120000 index OID. Not the bytes behind it — a link to a
     // directory has none, a dangling one has none, and a link to a file
     // outside the project would fold bytes `git diff` and `--affected`
-    // cannot see. A link to a file inside the project still tracks that
-    // file's content, because the file is an input in its own right. No
+    // cannot see. A link to a file inside the project tracks that file's
+    // content only when the file matches the task's globs too. No
     // memo: readlink is one syscall, and the row would be keyed on the
     // link's own stat, not its target's.
-    if (st.isSymbolicLink()) return this.hashBlob(new TextEncoder().encode(readlinkSync(filePath)))
+    if (st.isSymbolicLink()) {
+      return fileIdentity(
+        '120000',
+        this.hashBytes(new TextEncoder().encode(readlinkSync(filePath))),
+      )
+    }
+    // git's mode for a regular file: 100755 when the owner may execute it.
+    // The memo below holds the content alone; the mode rides this stat.
+    const mode = (st.mode & 0o100) !== 0 ? '100755' : '100644'
     const mtimeMs = Math.floor(st.mtimeMs)
     const size = st.size
     // ctime + ino are what make this memo SAFE, not merely fast. mtime is
@@ -107,7 +125,7 @@ export class FileHashStore {
       row.ctime_ms === ctimeMs &&
       row.ino === ino
     ) {
-      return row.content_hash
+      return fileIdentity(mode, row.content_hash)
     }
     const ch = await this.hashFileFromDisk(filePath)
     // git's racy-clean rule, applied to the memo: a stat taken in the same
@@ -118,10 +136,10 @@ export class FileHashStore {
     // changed within the window is hashed again on its next call rather
     // than memoised; the warm path never meets it (keys are derived long
     // after the files were written).
-    if (Date.now() - ctimeMs >= FILE_HASH_RACY_MS) {
+    if (this.write && Date.now() - ctimeMs >= FILE_HASH_RACY_MS) {
       this.upsertFileHash.run(filePath, mtimeMs, size, ctimeMs, ino, ch, Date.now())
     }
-    return ch
+    return fileIdentity(mode, ch)
   }
 
   /**
@@ -138,6 +156,8 @@ export class FileHashStore {
     const out = new Map<string, string>()
     if (paths.length === 0) return out
     interface Stat {
+      /** git's mode for it, as `hashFile` spells the identity. */
+      mode: string
       mtimeMs: number
       size: number
       ctimeMs: number
@@ -145,10 +165,26 @@ export class FileHashStore {
     }
     const stats = new Map<string, Stat>()
     for (const p of paths) {
-      if (stats.has(p)) continue
+      if (stats.has(p) || out.has(p)) continue
       try {
-        const st = statSync(p)
+        // lstat, not stat: `hashFile` folds a symlink as git folds it —
+        // the blob of its TARGET STRING — and this form promises the same
+        // digest. Following the link here instead hashed the target's
+        // BYTES, so the same path identified differently depending on
+        // which entry point the caller used, and the batch folded bytes
+        // `git diff` and `--affected` cannot see.
+        const st = lstatSync(p)
+        if (st.isSymbolicLink()) {
+          // No memo, for `hashFile`'s reason: the row would be keyed on
+          // the link's own stat, not its target's.
+          out.set(
+            p,
+            fileIdentity('120000', this.hashBytes(new TextEncoder().encode(readlinkSync(p)))),
+          )
+          continue
+        }
         stats.set(p, {
+          mode: (st.mode & 0o100) !== 0 ? '100755' : '100644',
           mtimeMs: Math.floor(st.mtimeMs),
           size: st.size,
           ctimeMs: Math.floor(st.ctimeMs),
@@ -187,7 +223,7 @@ export class FileHashStore {
           row.ctime_ms === st.ctimeMs &&
           row.ino === st.ino
         ) {
-          out.set(p, row.content_hash)
+          out.set(p, fileIdentity(st.mode, row.content_hash))
         } else misses.push(p)
       }
     }
@@ -202,10 +238,10 @@ export class FileHashStore {
         if (digest === undefined) continue
         const p = misses[i]!
         const st = stats.get(p)!
-        out.set(p, digest)
+        out.set(p, fileIdentity(st.mode, digest))
         // The same racy-clean rule as `hashFile`: a stat taken within the
         // window of the file's last change is not memoised.
-        if (now - st.ctimeMs >= FILE_HASH_RACY_MS) {
+        if (this.write && now - st.ctimeMs >= FILE_HASH_RACY_MS) {
           this.upsertFileHash.run(p, st.mtimeMs, st.size, st.ctimeMs, st.ino, digest, now)
         }
       }
@@ -221,11 +257,16 @@ export class FileHashStore {
    * spawn per file.
    */
   private async hashFileFromDisk(filePath: string): Promise<string> {
-    return this.hashBlob(await Bun.file(filePath).bytes(), filePath)
+    return this.hashBytes(await Bun.file(filePath).bytes(), filePath)
   }
 
-  /** `git hash-object` of `bytes`: the blob OID in the repo's object format. */
-  private hashBlob(bytes: Uint8Array, nearPath?: string): string {
+  /**
+   * `git hash-object` of `bytes`: the blob OID in the repo's object format —
+   * what `hashFile` returns for a file holding them, with no stat and no
+   * memo row. `nearPath` says which repo's format applies (the cache dir's
+   * when absent).
+   */
+  hashBytes(bytes: Uint8Array, nearPath?: string): string {
     const hasher = new Bun.CryptoHasher(
       this.objectFormat ?? this.detectObjectFormat(nearPath ?? this.cacheDir),
     )
@@ -236,26 +277,13 @@ export class FileHashStore {
 
   /**
    * Repo object format — sha1 unless the repo was created with
-   * `--object-format=sha256`. One `git rev-parse` spawn per Cache
-   * lifetime, and only when at least one file misses the mtime+size
-   * memo. Outside a repo (unit fixtures) we default to sha1, which is
-   * still a deterministic blob-OID domain.
+   * `--object-format=sha256`. Asked once per store, and only when at least
+   * one file misses the mtime+size memo; `repoFacts` shares the spawn with
+   * the input enumeration. Outside a repo (unit fixtures), or with no git,
+   * sha1, which is still a deterministic blob-OID domain.
    */
   private detectObjectFormat(nearPath: string): 'sha1' | 'sha256' {
-    let detected: 'sha1' | 'sha256' = 'sha1'
-    try {
-      const proc = Bun.spawnSync({
-        cmd: ['git', 'rev-parse', '--show-object-format'],
-        cwd: path.dirname(nearPath),
-        stdout: 'pipe',
-        stderr: 'pipe',
-      })
-      if (proc.exitCode === 0 && new TextDecoder().decode(proc.stdout).trim() === 'sha256') {
-        detected = 'sha256'
-      }
-    } catch {
-      // git unavailable → sha1 default keeps hashing deterministic.
-    }
+    const detected = repoFacts(this.repoDir ?? path.dirname(nearPath))?.objectFormat ?? 'sha1'
     this.objectFormat = detected
     return detected
   }