@vzn/vx 0.0.385 → 0.0.387

package/README.md

@@ -27,6 +27,8 @@
 
 vx N% faster: vx takes N% less time than that tool (1 − vx ÷ theirs); N% slower: N% more (vx ÷ theirs − 1).
 
+Nx's column ran every task through npm run (~200 ms of CPU each; Turbo ran bun run), a harness fault since fixed; with bun, on a 4-core Linux box, Nx took 6m 59s cold and 4.50 s fully cached (vx 47% and 92% faster).
+
 Time added is the wall time over the tasks' own ideal schedule (3 min 38 s).
 Same graph, commands and concurrency: [how it is measured](https://vznjs.github.io/vx/benchmarks/).
 

package/package.json

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

package/src/cache/cache.ts

@@ -25,7 +25,7 @@
 // this handle, declared by a plugin's `cache` hook. The contract every
 // layer speaks is `CacheLayer` in layer.ts; `plugin-host.ts` enforces it.
 
-import { Database, type SQLQueryBindings } from 'bun:sqlite'
+import { Database } from 'bun:sqlite'
 import {
   accessSync,
   closeSync,
@@ -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, lazyStatement } from './schema.js'
+import { createTables, inHashes, lazyStatement } from './schema.js'
 import {
   UserError,
   formatBytes,
@@ -973,16 +973,8 @@ export class Cache implements CacheLayer {
   private async getManyEntries(hashes: readonly string[]): Promise<Map<string, CacheEntry>> {
     const out = new Map<string, CacheEntry>()
     if (!this.read || hashes.length === 0) return out
-    const rows: EntryRow[] = []
-    for (let i = 0; i < hashes.length; i += 900) {
-      const chunk = hashes.slice(i, i + 900)
-      const placeholders = chunk.map(() => '?').join(',')
-      rows.push(
-        ...(this.db
-          .query(`${SELECT_ENTRY} WHERE e.hash IN (${placeholders})`)
-          .all(...(chunk as readonly SQLQueryBindings[])) as EntryRow[]),
-      )
-    }
+    const { test, params } = inHashes(hashes)
+    const rows = this.db.query(`${SELECT_ENTRY} WHERE e.hash ${test}`).all(...params) as EntryRow[]
     if (rows.length === 0) return out
     const present = rows.map((r) => existsSync(this.tarPath(r.hash)))
     const live = rows.filter((_r, i) => present[i])
@@ -1696,15 +1688,8 @@ export class Cache implements CacheLayer {
   }
 
   private writeAccessed(hashes: readonly string[], now: number): void {
-    // Chunked: SQLite's bound-parameter ceiling is 32k on modern
-    // builds, but 900 keeps us safe on any build at negligible cost.
-    for (let i = 0; i < hashes.length; i += 900) {
-      const chunk = hashes.slice(i, i + 900)
-      const placeholders = chunk.map(() => '?').join(',')
-      this.db
-        .prepare(`UPDATE entries SET accessed_at = ? WHERE hash IN (${placeholders})`)
-        .run(now, ...chunk)
-    }
+    const { test, params } = inHashes(hashes)
+    this.db.prepare(`UPDATE entries SET accessed_at = ? WHERE hash ${test}`).run(now, ...params)
   }
 
   /**
@@ -1900,13 +1885,9 @@ export class Cache implements CacheLayer {
       // space the unlinks free. Rows-first failed there before any file went,
       // and the one verb meant to free a full disk freed nothing (A-14).
       await Promise.all(hashes.map((h) => rm(this.tarPath(h), { force: true })))
+      const { test, params } = inHashes(rows)
       const deleteRows = this.db.transaction(() => {
-        for (let i = 0; i < rows.length; i += 900) {
-          const chunk = rows.slice(i, i + 900)
-          this.db
-            .prepare(`DELETE FROM entries WHERE hash IN (${chunk.map(() => '?').join(',')})`)
-            .run(...(chunk as readonly SQLQueryBindings[]))
-        }
+        this.db.prepare(`DELETE FROM entries WHERE hash ${test}`).run(...params)
       })
       try {
         deleteRows()

package/src/cache/output-index.ts

@@ -8,8 +8,8 @@
 /** `mtime_ms` of a recorded output prefix that did not exist when the snapshot was taken. */
 const ABSENT_DIR_MTIME = -1
 
-import type { Database, SQLQueryBindings } from 'bun:sqlite'
-import { lazyStatement } from './schema.js'
+import type { Database } from 'bun:sqlite'
+import { inHashes, lazyStatement } from './schema.js'
 import { lstatSync, statSync } from 'node:fs'
 import { lstat, readdir } from 'node:fs/promises'
 import path from 'node:path'
@@ -84,21 +84,18 @@ export class OutputIndex {
   loadOutputFilesBatch(hashes: readonly string[]): Map<string, OutputFileRow[]> {
     const out = new Map<string, OutputFileRow[]>()
     if (hashes.length === 0) return out
-    // Inline placeholders for an IN-list — bun:sqlite doesn't ship
-    // rarray, but `IN (?, ?, …)` with N≤~999 is fast and avoids per-
-    // hash select.get() overhead. `db.query` (not `db.prepare`) caches the
-    // compiled statement keyed by the SQL text — so the dominant single-hash
-    // warm-hit path (called up to 3× per hit) reuses one statement instead of
-    // recompiling on every call.
+    // `db.query` (not `db.prepare`) caches the compiled statement keyed by
+    // the SQL text, which `inHashes` keeps to two: the single-hash warm-hit
+    // path (called up to 3× per hit) reuses one instead of recompiling.
     // A reader in the same process (`vx watch`'s next cycle, a test) sees
     // the stamps taken, not only the ones flushed: overlaid below from
     // memory. A flush here committed a transaction per read, and a restore
     // reads its rows twice.
-    const placeholders = hashes.map(() => '?').join(',')
+    const { test, params } = inHashes(hashes)
     const stmt = this.db.query(
-      `SELECT entry_hash, path, size_bytes, mode, mtime_ms, ino, ctime_ms FROM output_files WHERE entry_hash IN (${placeholders})`,
+      `SELECT entry_hash, path, size_bytes, mode, mtime_ms, ino, ctime_ms FROM output_files WHERE entry_hash ${test}`,
     )
-    const rows = stmt.all(...(hashes as readonly SQLQueryBindings[])) as Array<{
+    const rows = stmt.all(...params) as Array<{
       entry_hash: string
       path: string
       size_bytes: number
@@ -324,12 +321,10 @@ export class OutputIndex {
     // A reader in the same process (`vx watch`'s next cycle, a test) sees
     // what was snapshotted, not what was flushed.
     this.flushOutputDirs()
-    const placeholders = hashes.map(() => '?').join(',')
+    const { test, params } = inHashes(hashes)
     const rows = this.db
-      .query(
-        `SELECT entry_hash, path, mtime_ms FROM output_dirs WHERE entry_hash IN (${placeholders})`,
-      )
-      .all(...(hashes as readonly SQLQueryBindings[])) as Array<{
+      .query(`SELECT entry_hash, path, mtime_ms FROM output_dirs WHERE entry_hash ${test}`)
+      .all(...params) as Array<{
       entry_hash: string
       path: string
       mtime_ms: number

package/src/cache/schema.ts

@@ -242,3 +242,16 @@ export function createTables(db: Database): void {
     );
   `)
 }
+
+/**
+ * A `WHERE <column> …` test against many hashes, as one statement whatever
+ * their number. A list of `?` is a new statement per length, compiled each
+ * run: 2.0 ms against 1.4 for 900 hashes through `json_each` (2026-10-03).
+ * One hash keeps `= ?`, ~3 µs cheaper than parsing a one-element array, on
+ * the per-hit path that asks for one at a time.
+ */
+export function inHashes(hashes: readonly string[]): { test: string; params: string[] } {
+  return hashes.length === 1
+    ? { test: '= ?', params: [hashes[0]!] }
+    : { test: 'IN (SELECT value FROM json_each(?))', params: [JSON.stringify(hashes)] }
+}