@vzn/vx 0.0.389 → 0.0.391

package/package.json

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

package/src/cache/run-history.ts

@@ -7,6 +7,30 @@ import type { Database, SQLQueryBindings } from 'bun:sqlite'
 import { lazyStatement } from './schema.js'
 import type { InvocationRecord, RunRecord } from './layer.js'
 
+const INSERT_RUNS = `
+      INSERT INTO runs(
+        hash, project, task, status, exit_code, duration_ms, forward_args,
+        started_at, ended_at,
+        run_id, cpu_ms, peak_rss_bytes, wallclock_start_ns, wallclock_end_ns,
+        cache_hit, attempts, cached,
+        blocked_by, timed_out, sandbox_violations, not_ready
+      )
+      VALUES `
+/** One `runs` row's placeholders: the 21 columns `bindRun` fills. */
+const RUN_TUPLE = `(${Array(21).fill('?').join(', ')})`
+
+/** An INSERT of `n` `runs` rows. */
+function insertRunsSql(n: number): string {
+  return INSERT_RUNS + Array(n).fill(RUN_TUPLE).join(', ')
+}
+
+/**
+ * Rows per INSERT: 40 × 21 variables stays under 999, the oldest default
+ * ceiling. A statement per row was 8.7 ms of 1,000 rows, 40 at a time 6.4
+ * (2026-10-03).
+ */
+const RUNS_PER_INSERT = 40
+
 export class RunHistory {
   private readonly insertRun: ReturnType<Database['prepare']>
   private readonly insertInvocation: ReturnType<Database['prepare']>
@@ -16,19 +40,7 @@ export class RunHistory {
     /** The store's salted value digest (L-4). */
     private readonly digestValue: (value: string) => string,
   ) {
-    this.insertRun = lazyStatement(
-      this.db,
-      `
-      INSERT INTO runs(
-        hash, project, task, status, exit_code, duration_ms, forward_args,
-        started_at, ended_at,
-        run_id, cpu_ms, peak_rss_bytes, wallclock_start_ns, wallclock_end_ns,
-        cache_hit, attempts, cached,
-        blocked_by, timed_out, sandbox_violations, not_ready
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,  ?, ?, ?, ?, ?,  ?, ?, ?,  ?, ?, ?, ?)
-    `,
-    )
+    this.insertRun = lazyStatement(this.db, insertRunsSql(1))
     this.insertInvocation = lazyStatement(
       this.db,
       `
@@ -59,11 +71,24 @@ export class RunHistory {
     // `bun:sqlite`'s `transaction()` returns a callable that wraps the
     // body in BEGIN/COMMIT, fsyncing once at the end. For a 200-task
     // run that's one fsync instead of 200.
-    const insert = this.insertRun
-    const tx = this.db.transaction((batch: readonly RunRecord[]) => {
-      for (const r of batch) insert.run(...bindRun(r, this.digestValue))
-    })
-    tx(runs)
+    this.db.transaction(() => this.insertRuns(runs))()
+  }
+
+  /** `runs` as few INSERTs; each distinct forward-args list digested once. */
+  private insertRuns(runs: readonly RunRecord[]): void {
+    const digests = new Map<string, string>()
+    const digest = (value: string): string => {
+      let d = digests.get(value)
+      if (d === undefined) digests.set(value, (d = this.digestValue(value)))
+      return d
+    }
+    for (let i = 0; i < runs.length; i += RUNS_PER_INSERT) {
+      const block = runs.slice(i, i + RUNS_PER_INSERT)
+      const params: SQLQueryBindings[] = []
+      for (const r of block) params.push(...bindRun(r, digest))
+      // `query` caches by text: one statement for every full block.
+      this.db.query(insertRunsSql(block.length)).run(...params)
+    }
   }
 
   recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
@@ -73,11 +98,9 @@ export class RunHistory {
     // the entry-save transaction (`save`/`ingest`) so a warm
     // all-cache-hit run — which writes no `runs`-vs-`entry_inputs`
     // mismatch — pays nothing for the moat it isn't refreshing.
-    const insertRun = this.insertRun
-    const insertInvocation = this.insertInvocation
     this.db.transaction(() => {
-      for (const r of bundle.runs) insertRun.run(...bindRun(r, this.digestValue))
-      insertInvocation.run(...bindInvocation(bundle.invocation))
+      this.insertRuns(bundle.runs)
+      this.insertInvocation.run(...bindInvocation(bundle.invocation))
     })()
   }
 

package/src/index.ts

@@ -51,7 +51,7 @@ export type {
   SandboxDenials,
 } from './config.js'
 export { defineProject, defineWorkspace } from './config.js'
-export { definePlugin } from './orchestrator/index.js'
+export { definePlugin, refuseUnknownOptions } from './orchestrator/index.js'
 
 // Programmatic engine API: run / plan / prepare (docs/cli.md § Programmatic
 // API). The graph primitives, the cache-key hashing seam and the git / host

package/src/orchestrator/index.ts

@@ -86,6 +86,7 @@ export {
   type FingerprintContext,
   type VxPlugin,
   definePlugin,
+  refuseUnknownOptions,
   type PluginHooks,
   type PluginOrigin,
 } from './plugin.js'

package/src/orchestrator/plugin.ts

@@ -15,7 +15,7 @@ import type { Cache, CacheLayer, CachePolicy } from '../cache/index.js'
 import { PLUGIN_PACKAGE, type ProjectConfig, type WorkspaceConfig } from '../config.js'
 import type { TaskExecutor } from '../exec/index.js'
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
-import { UserError } from '../util/index.js'
+import { nearest, UserError } from '../util/index.js'
 import type { ProjectMeta } from '../workspace/index.js'
 import type { EventBus, RunStartInfo } from './events.js'
 import type { TelemetryContext, TelemetrySink } from './telemetry.js'
@@ -483,6 +483,32 @@ export function definePlugin(origin: PluginOrigin, hooks: PluginHooks): VxPlugin
   return { ...hooks, name, [PLUGIN_PACKAGE]: name } as VxPlugin
 }
 
+/**
+ * Refuse an option a plugin factory does not take, as core refuses an
+ * unknown config field. Bun strips a config's types, so a misspelt option
+ * (`reapi({ endpont })`) reached the factory, which read it as unset and
+ * quietly declined: the run went local with no word. `factory` names the
+ * call in the message (`reapi()`), `known` is the options the factory reads.
+ */
+export function refuseUnknownOptions(
+  factory: string,
+  options: unknown,
+  known: readonly string[],
+): void {
+  if (options === undefined) return
+  if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+    throw new UserError(`${factory}: options must be an object`)
+  }
+  for (const key of Object.keys(options)) {
+    if (known.includes(key)) continue
+    const near = nearest(key, known)
+    throw new UserError(
+      `${factory} has unknown option "${key}" (allowed: ${[...known].sort().join(', ')})` +
+        (near === undefined ? '' : ` — did you mean ${near}?`),
+    )
+  }
+}
+
 export interface InstallPluginsArgs {
   plugins: readonly Plugin[]
   workspaceRoot: string

package/src/orchestrator/run.ts

@@ -1270,12 +1270,26 @@ async function runOnBus(
     // for it, and an exit 1 with no word about why is a mystery in a log.
     if (keepAlive.children.length > 0 && hold) {
       const held = keepAlive.children
+      // A held server that dies on its own is said, as the foreground's
+      // keep-alive says it: `vx watch` sat on "watching" over a dead dev
+      // server. The holder's own stop() is not such a death.
+      let stopping = false
+      keepAlive.nodes.forEach((n, i) => {
+        // One that died during the graph was said then.
+        if (hasEnded(held[i]!)) return
+        void held[i]!.exited.then((code) => {
+          if (!stopping && code !== 0) log.status(`vx: ${n.id} exited with code ${code}`)
+        })
+      })
       return {
         ok,
         outcomes: list,
         persistent: {
           ids: keepAlive.nodes.map((n) => n.id),
-          stop: (signal) => terminateChildren(() => held, signal),
+          stop: (signal) => {
+            stopping = true
+            return terminateChildren(() => held, signal)
+          },
         },
       }
     }