@vzn/vx 0.0.380 → 0.0.382

package/package.json

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

package/src/cache/cache.ts

@@ -38,7 +38,7 @@ import {
 } from 'node:fs'
 import { readdir, rm, stat, unlink, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { createTables } from './schema.js'
+import { createTables, lazyStatement } from './schema.js'
 import {
   UserError,
   formatBytes,
@@ -451,7 +451,6 @@ export class Cache implements CacheLayer {
   private readonly upsertStdout: ReturnType<Database['prepare']>
   private readonly deleteStdout: ReturnType<Database['prepare']>
   private readonly entryExists: ReturnType<Database['prepare']>
-  private readonly bumpAccessed: ReturnType<Database['prepare']>
   private readonly touched = new Set<string>()
   private readonly insertEntryInput: ReturnType<Database['prepare']>
   /** The per-file (mtime, size) → blob-OID memo behind `hashFile`. */
@@ -706,8 +705,10 @@ export class Cache implements CacheLayer {
 
     createTables(this.db)
 
-    this.deleteEntryRow = this.db.prepare('DELETE FROM entries WHERE hash = ?')
-    this.insertEntry = this.db.prepare(`
+    this.deleteEntryRow = lazyStatement(this.db, 'DELETE FROM entries WHERE hash = ?')
+    this.insertEntry = lazyStatement(
+      this.db,
+      `
       INSERT INTO entries(hash, project, task, command, exit_code, duration_ms, size_bytes, created_at, accessed_at, cpu_ms, peak_rss_bytes)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(hash) DO UPDATE SET
@@ -720,25 +721,29 @@ export class Cache implements CacheLayer {
         accessed_at    = excluded.accessed_at,
         cpu_ms         = excluded.cpu_ms,
         peak_rss_bytes = excluded.peak_rss_bytes
-    `)
-    this.upsertStdout = this.db.prepare(
+    `,
+    )
+    this.upsertStdout = lazyStatement(
+      this.db,
       'INSERT INTO entry_stdout(hash, stdout) VALUES (?, ?) ON CONFLICT(hash) DO UPDATE SET stdout = excluded.stdout',
     )
-    this.deleteStdout = this.db.prepare('DELETE FROM entry_stdout WHERE hash = ?')
-    this.selectEntry = this.db.prepare(`${SELECT_ENTRY} WHERE e.hash = ?`)
+    this.deleteStdout = lazyStatement(this.db, 'DELETE FROM entry_stdout WHERE hash = ?')
+    this.selectEntry = lazyStatement(this.db, `${SELECT_ENTRY} WHERE e.hash = ?`)
     // `has` asks only whether the row is there, with no stdout joined. A
     // column off the index, so the table row is still read and a corrupt
     // table refuses here as it does on `get` (`SELECT 1` answers from the
     // index alone).
-    this.entryExists = this.db.prepare('SELECT exit_code FROM entries WHERE hash = ?')
-    this.bumpAccessed = this.db.prepare('UPDATE entries SET accessed_at = ? WHERE hash = ?')
+    this.entryExists = lazyStatement(this.db, 'SELECT exit_code FROM entries WHERE hash = ?')
     // INSERT OR IGNORE: re-saving the same hash (idempotent ingest /
     // overlapping concurrent saves) leaves the existing rows untouched —
     // identical inputs derive the identical hash, so the rows are too.
-    this.insertEntryInput = this.db.prepare(`
+    this.insertEntryInput = lazyStatement(
+      this.db,
+      `
       INSERT OR IGNORE INTO entry_inputs(entry_hash, kind, name, hash)
       VALUES (?, ?, ?, ?)
-    `)
+    `,
+    )
     // The slices: each owns its statements over this handle and its table(s);
     // the schema above is the one place every table is declared.
     this.files = new FileHashStore(this.db, cacheDir, this.write, repoDir)

package/src/cache/config-evals.ts

@@ -4,6 +4,7 @@
 // Owns its statements over the store's handle; `Cache` delegates.
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
+import { lazyStatement } from './schema.js'
 
 export class ConfigEvalTable {
   private readonly selectConfigEval: ReturnType<Database['prepare']>
@@ -18,11 +19,13 @@ export class ConfigEvalTable {
   ) {
     this.read = policy.read
     this.write = policy.write
-    this.selectConfigEval = this.db.prepare('SELECT json FROM config_evals WHERE key = ?')
-    this.insertConfigEval = this.db.prepare(
+    this.selectConfigEval = lazyStatement(this.db, 'SELECT json FROM config_evals WHERE key = ?')
+    this.insertConfigEval = lazyStatement(
+      this.db,
       'INSERT OR REPLACE INTO config_evals(key, json, created_at) VALUES (?, ?, ?)',
     )
-    this.upsertConfigClosure = this.db.prepare(
+    this.upsertConfigClosure = lazyStatement(
+      this.db,
       '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',
     )
   }

package/src/cache/file-hashes.ts

@@ -7,6 +7,7 @@
 // the store's handle; `Cache` delegates.
 
 import type { Database } from 'bun:sqlite'
+import { lazyStatement } from './schema.js'
 import { lstatSync, readlinkSync } from 'node:fs'
 import path from 'node:path'
 import { fileIdentity, repoFacts } from './git-inputs.js'
@@ -35,10 +36,13 @@ export class FileHashStore {
      */
     private readonly repoDir?: string,
   ) {
-    this.selectFileHash = this.db.prepare(
+    this.selectFileHash = lazyStatement(
+      this.db,
       'SELECT mtime_ms, size_bytes, ctime_ms, ino, content_hash FROM file_hashes WHERE path = ?',
     )
-    this.upsertFileHash = this.db.prepare(`
+    this.upsertFileHash = lazyStatement(
+      this.db,
+      `
       INSERT INTO file_hashes(path, mtime_ms, size_bytes, ctime_ms, ino, content_hash, seen_at)
       VALUES (?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(path) DO UPDATE SET
@@ -48,7 +52,8 @@ export class FileHashStore {
         ino          = excluded.ino,
         content_hash = excluded.content_hash,
         seen_at      = excluded.seen_at
-    `)
+    `,
+    )
   }
 
   /**

package/src/cache/output-index.ts

@@ -9,6 +9,7 @@
 const ABSENT_DIR_MTIME = -1
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
+import { lazyStatement } from './schema.js'
 import { lstatSync, statSync } from 'node:fs'
 import { lstat, readdir } from 'node:fs/promises'
 import path from 'node:path'
@@ -42,21 +43,26 @@ export class OutputIndex {
   private readonly pendingStamps = new Map<string, Array<[string, number, number]>>()
 
   constructor(private readonly db: Database) {
-    this.insertOutputFile = this.db.prepare(`
+    this.insertOutputFile = lazyStatement(
+      this.db,
+      `
       INSERT INTO output_files(entry_hash, path, size_bytes, mode, mtime_ms)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(entry_hash, path) DO UPDATE SET
         size_bytes = excluded.size_bytes,
         mode       = excluded.mode,
         mtime_ms   = excluded.mtime_ms
-    `)
-    this.deleteOutputFiles = this.db.prepare('DELETE FROM output_files WHERE entry_hash = ?')
-    this.insertOutputDir = this.db.prepare(
+    `,
+    )
+    this.deleteOutputFiles = lazyStatement(this.db, 'DELETE FROM output_files WHERE entry_hash = ?')
+    this.insertOutputDir = lazyStatement(
+      this.db,
       'INSERT INTO output_dirs(entry_hash, path, mtime_ms) VALUES (?, ?, ?)',
     )
-    this.deleteOutputDirs = this.db.prepare('DELETE FROM output_dirs WHERE entry_hash = ?')
-    this.entryExists = this.db.prepare('SELECT 1 FROM entries WHERE hash = ?')
-    this.stampOutputFile = this.db.prepare(
+    this.deleteOutputDirs = lazyStatement(this.db, 'DELETE FROM output_dirs WHERE entry_hash = ?')
+    this.entryExists = lazyStatement(this.db, 'SELECT 1 FROM entries WHERE hash = ?')
+    this.stampOutputFile = lazyStatement(
+      this.db,
       'UPDATE output_files SET ino = ?, ctime_ms = ? WHERE entry_hash = ? AND path = ?',
     )
   }

package/src/cache/run-history.ts

@@ -4,6 +4,7 @@
 // its statements over the store's handle; `Cache` delegates.
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
+import { lazyStatement } from './schema.js'
 import type { InvocationRecord, RunRecord } from './layer.js'
 
 export class RunHistory {
@@ -15,7 +16,9 @@ export class RunHistory {
     /** The store's salted value digest (L-4). */
     private readonly digestValue: (value: string) => string,
   ) {
-    this.insertRun = this.db.prepare(`
+    this.insertRun = lazyStatement(
+      this.db,
+      `
       INSERT INTO runs(
         hash, project, task, status, exit_code, duration_ms, forward_args,
         started_at, ended_at,
@@ -24,8 +27,11 @@ export class RunHistory {
         blocked_by, timed_out, sandbox_violations, not_ready
       )
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,  ?, ?, ?, ?, ?,  ?, ?, ?,  ?, ?, ?, ?)
-    `)
-    this.insertInvocation = this.db.prepare(`
+    `,
+    )
+    this.insertInvocation = lazyStatement(
+      this.db,
+      `
       INSERT INTO invocations(
         run_id, command, requested_tasks, cache_policy, concurrency, flow,
         started_at, ended_at, total_duration_ms,
@@ -36,7 +42,8 @@ export class RunHistory {
       )
       VALUES (?, ?, ?, ?, ?, ?,  ?, ?, ?,  ?, ?, ?, ?, ?,  ?,  ?, ?, ?, ?, ?,  ?, ?, ?, ?, ?)
       ON CONFLICT(run_id) DO NOTHING
-    `)
+    `,
+    )
   }
 
   recordRun(run: RunRecord): void {

package/src/cache/schema.ts

@@ -3,7 +3,21 @@
 // them lives in the store that owns the table (file-hashes, config-evals,
 // output-index, history) or in cache.ts for `entries` and `entry_inputs`.
 
-import type { Database } from 'bun:sqlite'
+import type { Database, SQLQueryBindings } from 'bun:sqlite'
+
+/**
+ * A statement prepared on its first `run` or `get`. A warm run executes few
+ * of the index's statements, and preparing every one at the open cost each
+ * run ~0.4 ms (2026-10-03).
+ */
+export function lazyStatement(db: Database, sql: string): ReturnType<Database['prepare']> {
+  let statement: ReturnType<Database['prepare']> | undefined
+  const prepared = (): ReturnType<Database['prepare']> => (statement ??= db.prepare(sql))
+  return {
+    run: (...params: SQLQueryBindings[]) => prepared().run(...params),
+    get: (...params: SQLQueryBindings[]) => prepared().get(...params),
+  } as unknown as ReturnType<Database['prepare']>
+}
 
 export function createTables(db: Database): void {
   // Cached config evaluations (workspace/config-cache.ts): the validated