@sproutboat/runtime 0.34.5 → 0.36.0

package/test/native-cpu-requests.ts

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// Per-request CPU (design 02): x-sb-cpu-ms counts the thread CPU time of the slices in which one
+// request ran. A spinner interleaved with requests that wait is charged for its own work, the
+// waiters for theirs, whatever order they run in. An async handler reports it from compatibility
+// date 2026-11-02; before that only a handler that answers synchronously does.
+const handler = `export default {async fetch(request) {
+  const url = new URL(request.url);
+  const ms = Number(url.searchParams.get("ms") || 0);
+  const sleep = (n) => new Promise((resolve) => setTimeout(resolve, n));
+  // Work, not wall time: a loaded machine deschedules the process, and CPU time must not follow wall time.
+  const spin = (n) => { let x = 1; for (let i = 0; i < n * 40000; i++) x = (x * 1.0000001 + i) % 1000003; return x; };
+  if (url.pathname === "/spin") {
+    await sleep(5);
+    spin(ms / 2);
+    await sleep(5);
+    spin(ms / 2);
+    return new Response("spun");
+  }
+  if (url.pathname === "/wait") {
+    await sleep(ms);
+    return new Response("waited");
+  }
+  if (url.pathname === "/sync") {
+    spin(ms);
+    return new Response("sync");
+  }
+  return new Response("none", { status: 404 });
+}};`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-cpu-requests-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+async function build(date: string): Promise<number> {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native cpu test needs node on PATH");
+  const [core, broker] = await Promise.all([readFile(preludePath, "utf8"), readFile(transportPath("broker"), "utf8")]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const generated = join(workdir, `cpu-${date}.generated.js`);
+  const binary = join(workdir, `cpu-${date}`);
+  await writeFile(
+    generated,
+    wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker), undefined, undefined, undefined, date),
+  );
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      env: process.env,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+  const port = freePort();
+  const server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  servers.push(server);
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/none`, { signal: AbortSignal.timeout(500) });
+      return port;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  throw new Error("compiled handler did not start");
+}
+
+try {
+  const port = await build("2026-11-02");
+  const cpu = async (path: string) => {
+    const response = await fetch(`http://127.0.0.1:${port}${path}`);
+    await response.text();
+    const header = response.headers.get("x-sb-cpu-ms");
+    assert(header !== null, `${path} has no x-sb-cpu-ms`);
+    return Number(header);
+  };
+
+  const alone = await cpu("/spin?ms=200");
+  assert(alone > 10, `a spinner alone reports only ${alone} ms`);
+  const sync = await cpu("/sync?ms=200");
+  assert(
+    sync > alone * 0.5 && sync < alone * 2,
+    `a synchronous spinner of the same work reports ${sync} ms, the async one ${alone}`,
+  );
+  const idle = await cpu("/wait?ms=50");
+  assert(idle < alone / 4 && idle < 30, `a request that only waits reports ${idle} ms (a spinner: ${alone})`);
+
+  // Together: the spinner next to eight waiters, repeated so the slices interleave differently.
+  for (let round = 0; round < 3; round++) {
+    const results = await Promise.all([
+      cpu("/spin?ms=200"),
+      ...Array.from({ length: 8 }, (_, i) => cpu(`/wait?ms=${150 + i * 20}`)),
+    ]);
+    const [spinner, ...waiters] = results;
+    assert(
+      spinner > alone * 0.5 && spinner < alone * 2,
+      `round ${round}: the spinner reports ${spinner} ms, alone it did ${alone}`,
+    );
+    for (const waiter of waiters)
+      assert(
+        waiter < alone / 4 && waiter < 60,
+        `round ${round}: a waiter was charged ${waiter} ms (the spinner: ${spinner})`,
+      );
+  }
+  // Two spinners at once are each charged their own work, not both.
+  const [a, b] = await Promise.all([cpu("/spin?ms=200"), cpu("/spin?ms=200")]);
+  assert(
+    a > alone * 0.5 && a < alone * 1.6 && b > alone * 0.5 && b < alone * 1.6,
+    `two spinners report ${a} and ${b} ms, one alone ${alone}`,
+  );
+  console.log(`per-request CPU holds under interleaving (a spinner ${alone.toFixed(0)} ms, waiters a few ms)`);
+
+  // Before 2026-11-02 an async handler still reports nothing.
+  const oldPort = await build("2026-11-01");
+  const old = await fetch(`http://127.0.0.1:${oldPort}/spin?ms=20`);
+  await old.text();
+  assert.equal(old.headers.get("x-sb-cpu-ms"), null, "an async handler is stamped before 2026-11-02");
+  const oldSync = await fetch(`http://127.0.0.1:${oldPort}/sync?ms=20`);
+  await oldSync.text();
+  assert.equal(
+    oldSync.headers.get("x-sb-cpu-ms"),
+    null,
+    "this handler is async, so it is not stamped before 2026-11-02",
+  );
+  console.log("before 2026-11-02 an async handler is not stamped");
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-d1.ts

@@ -56,12 +56,18 @@ int main(void) {
     if (!strncmp(line, ":cells ", 7)) {
       sb_cells cs = { 0, 0, 0, 0, 0 };
       char* head = sb_sql_run_x(line + 7, sql, params, &cs);
-      printf("{\\"head\\":%s,\\"rows\\":[", head);
-      size_t nrow = cs.ncol ? cs.n / (size_t)cs.ncol : 0;
+      // A result has no JSON header: its column names are the first cells and its counts are in cs.
+      if (head) printf("{\\"head\\":%s,\\"rows\\":[", head);
+      else {
+        printf("{\\"head\\":{\\"ok\\":true,\\"cols\\":[");
+        for (int c = 0; c < cs.hdr; c++) printf(c ? ",\\"%.*s\\"" : "\\"%.*s\\"", cs.c[c].n, cs.a + cs.c[c].off);
+        printf("],\\"changes\\":%lld,\\"rowid\\":%lld},\\"rows\\":[", cs.changes, cs.rowid);
+      }
+      size_t nrow = cs.ncol ? (cs.n - (size_t)cs.hdr) / (size_t)cs.ncol : 0;
       for (size_t r = 0; r < nrow; r++) {
         printf(r ? ",[" : "[");
         for (int c = 0; c < cs.ncol; c++) {
-          sb_cell* x = &cs.c[r * (size_t)cs.ncol + (size_t)c];
+          sb_cell* x = &cs.c[(size_t)cs.hdr + r * (size_t)cs.ncol + (size_t)c];
           if (c) printf(",");
           if (x->t == 0) printf("null");
           else if (x->t == 1) printf("%.17g", x->d);
@@ -162,6 +168,7 @@ int main(void) {
     assert.deepEqual(cells.rows, json.rows, `cells equal the JSON rows for ${t}`);
     assert.deepEqual(cells.head.cols, json.cols);
     assert.equal(cells.head.changes, json.changes);
+    assert.equal(cells.head.rowid, json.rowid);
   }
   const empty = cellRun("SELECT a FROM t WHERE 0");
   assert.deepEqual(empty.cells.rows, []);
@@ -252,15 +259,16 @@ int main(void) {
   };
   // oxlint-disable-next-line no-function-constructor -- lifting a block out of the text-only transport
   const scriptRaw = (path: string, text: string) => sqlRaw(":script " + path, text, "[]");
-  // __sbSqlRowsRaw as the transport's C block gives it: [header JSON, rows], BLOBs as byte arrays.
+  // __sbSqlRowsRaw as the transport's C block gives it: an error is [header JSON], a result is
+  // ["", rows, columns, changes, rowid], BLOBs as byte arrays.
   const rowsOf =
     (raw: (path: string, text: string, params: string) => string) => (path: string, text: string, params: string) => {
       const r = JSON.parse(raw(":cells " + path, text, params));
-      if (r.head.ok === false) return [JSON.stringify(r.head), undefined];
+      if (r.head.ok === false) return [JSON.stringify(r.head)];
       const rows = r.rows.map((row: unknown[]) =>
         row.map((c) => (c instanceof Object && "$blob" in c ? [...Buffer.from(String(c.$blob), "hex")] : c)),
       );
-      return [JSON.stringify(r.head), rows];
+      return ["", rows, r.head.cols, r.head.changes, r.head.rowid];
     };
   const ops = new Function(
     "__sbSqlRaw",
@@ -279,6 +287,7 @@ int main(void) {
       "__sbDir",
       "__sbDirBytesRaw",
       "__sbD1DbRaw",
+      "__sbD1Captured_",
       "__sbSql",
       "__sbSqlRaw",
       `${transport.slice(quotaStart, quotaEnd)}\nreturn { __sbQuotaCheck, __sbD1Quota, __sbQuotaFull, expire() { __sbQuotaAt = -1; } };`,
@@ -287,6 +296,7 @@ int main(void) {
       () => dir,
       (d: string) => String(JSON.parse(sqlRaw(":bytes " + d, "", "")).n),
       (path: string, what: string) => String(JSON.parse(sqlRaw(":db " + path, what, "")).n),
+      (path: string) => JSON.parse(sqlRaw(":db " + path, "c", "")).n,
       sql,
       sqlRaw,
     );
@@ -334,6 +344,7 @@ int main(void) {
         "__sbDir",
         "__sbDirBytesRaw",
         "__sbD1DbRaw",
+        "__sbD1Captured_",
         "__sbSql",
         "__sbSqlRaw",
         `${transport.slice(quotaStart, quotaEnd)}\nreturn { __sbQuotaCheck, __sbD1Quota, __sbQuotaFull };`,
@@ -342,6 +353,7 @@ int main(void) {
         () => dir,
         (d: string) => String(JSON.parse(raw(":bytes " + d, "", "")).n),
         (path: string, what: string) => String(JSON.parse(raw(":db " + path, what, "")).n),
+        (path: string) => JSON.parse(raw(":db " + path, "c", "")).n,
         run,
         raw,
       );
@@ -629,6 +641,24 @@ int main(void) {
   assert.match(failedOver.error, /^LTX capture failed/);
   third.close();
   await third.exited;
+  // Locking mode. This driver is the transport on its own, as sproutd and the broker embed it (no
+  // standalone shim): unset it must stay shared, so those hosts behave as before. SB_SQLITE_EXCLUSIVE=1 is
+  // exclusive for a plain database; anything else, 0 included, is shared. A database under LTX replication
+  // is never exclusive.
+  const lockingMode = (env: Record<string, string>, path: string) => {
+    const e = Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== "SB_SQLITE_EXCLUSIVE"));
+    const p = Bun.spawnSync([binary], {
+      stdin: Buffer.from(`${path}\tPRAGMA locking_mode\t[]\n`),
+      env: { ...e, ...env },
+    });
+    assert.equal(p.exitCode, 0, p.stderr.toString());
+    return JSON.parse(p.stdout.toString().trim()).rows[0][0];
+  };
+  const lockDb = join(work, "data/d1/LOCK.sqlite");
+  assert.equal(lockingMode({}, lockDb), "normal", "the bare transport keeps shared locking unless asked");
+  assert.equal(lockingMode({ SB_SQLITE_EXCLUSIVE: "0" }, lockDb), "normal");
+  assert.equal(lockingMode({ SB_SQLITE_EXCLUSIVE: "1" }, lockDb), "exclusive");
+  assert.equal(lockingMode({ SB_SQLITE_EXCLUSIVE: "1" }, join(work, "data/d1/LOCK2.sqlite")), "exclusive");
   console.log(
     "native d1: sb_sql_run and the D1 ops pass (blob binds, atomic batch, strict counts, foreign keys, error text)",
   );

package/test/native-headers.ts

@@ -0,0 +1,182 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// Headers validates a name and trims a value in C before it falls back to the regular expression and
+// the JS loops. Every kind of name and value must come out as the Fetch spec says: valid names
+// lowercased, invalid ones a TypeError, values trimmed, forbidden characters refused, and a name
+// that is not a plain bytestring (a wide character) still judged by the expression.
+const handler = `export default {fetch(request) {
+  const out = {};
+  const names = ["a", "Content-Type", "X-Sb-Test", "x_y", "a.b", "a~b", "a|b", "a^b", "a+b", "a*b", "a!b", "a#b", "a$b", "a%b", "a&b", "a'b", "a-b", "9", "A9z", "",
+    "a b", "a:b", "a/b", "a(b", "a@b", "a[b", "a\\u0000b", "a\\nb", "\\u00e9", "caf\\u00e9", "a\\u0100b", "a,b", "a;b", "a=b", "a?b", "a\\"b", "a\\\\b", "a<b", "a>b", "a{b", "a}b"];
+  const h = new Headers();
+  for (const name of names) {
+    try { h.append(name, "v"); out["n:" + name] = h.has(name.toLowerCase()) ? "ok" : "stored?"; }
+    catch (e) { out["n:" + name] = e instanceof TypeError ? "TypeError" : String(e); }
+  }
+  const values = ["plain", "", " lead", "trail ", "\\t both \\t", "\\r\\nx", "a\\u0000b", "a\\nb", "a\\rb", "in ner", "caf\\u00e9", "\\u4e2d", " \\u4e2d ", "x\\ty"];
+  for (const value of values) {
+    const g = new Headers();
+    try { g.set("x", value); out["v:" + JSON.stringify(value)] = g.get("x"); }
+    catch (e) { out["v:" + JSON.stringify(value)] = e instanceof TypeError ? "TypeError" : String(e); }
+  }
+  const dup = new Headers();
+  dup.append("Accept", "a"); dup.append("accept", "b");
+  out.dup = dup.get("ACCEPT");
+  out.fromObject = new Headers({ "Content-Type": "text/plain", "X-A": " 1 " }).get("x-a");
+  out.getCase = new Headers({ "x-a": "1" }).get("X-A");
+  out.trigger = request.headers.get("X-Sb-Trigger");
+  out.custom = request.headers.get("X-Custom");
+  return new Response(JSON.stringify(out), { headers: { "Content-Type": "application/json", "X-Case": " kept " } });
+}};`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+// What the Fetch spec (and workerd) say, from the names and values above.
+function expectedName(name: string): string {
+  const valid = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name);
+  return valid ? "ok" : "TypeError";
+}
+function expectedValue(value: string): string {
+  const trimmed = value.replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, "");
+  return /[\0\n\r]/.test(trimmed) ? "TypeError" : trimmed;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-headers-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native headers test needs node on PATH");
+
+  const [core, broker] = await Promise.all([readFile(preludePath, "utf8"), readFile(transportPath("broker"), "utf8")]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "headers.generated.js");
+  const binary = join(workdir, "headers-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+  await rm(binary, { force: true });
+
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      env: process.env,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+  const port = freePort();
+  server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let response: Response | undefined;
+  for (let attempt = 0; attempt < 50 && !response; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, {
+        headers: { "X-Custom": "custom" },
+        signal: AbortSignal.timeout(2000),
+      });
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled handler did not start");
+  // SAFETY: the handler above answers a flat JSON object of strings (and null), read key by key below.
+  const out = (await response.json()) as Record<string, string>;
+  const names = [
+    "a",
+    "Content-Type",
+    "X-Sb-Test",
+    "x_y",
+    "a.b",
+    "a~b",
+    "a|b",
+    "a^b",
+    "a+b",
+    "a*b",
+    "a!b",
+    "a#b",
+    "a$b",
+    "a%b",
+    "a&b",
+    "a'b",
+    "a-b",
+    "9",
+    "A9z",
+    "",
+    "a b",
+    "a:b",
+    "a/b",
+    "a(b",
+    "a@b",
+    "a[b",
+    "a\u0000b",
+    "a\nb",
+    "é",
+    "café",
+    "aĀb",
+    "a,b",
+    "a;b",
+    "a=b",
+    "a?b",
+    'a"b',
+    "a\\b",
+    "a<b",
+    "a>b",
+    "a{b",
+    "a}b",
+  ];
+  for (const name of names) assert.equal(out["n:" + name], expectedName(name), `header name ${JSON.stringify(name)}`);
+  const values = [
+    "plain",
+    "",
+    " lead",
+    "trail ",
+    "\t both \t",
+    "\r\nx",
+    "a\u0000b",
+    "a\nb",
+    "a\rb",
+    "in ner",
+    "café",
+    "中",
+    " 中 ",
+    "x\ty",
+  ];
+  for (const value of values)
+    assert.equal(out["v:" + JSON.stringify(value)], expectedValue(value), `header value ${JSON.stringify(value)}`);
+  assert.equal(out.dup, "a, b");
+  assert.equal(out.fromObject, "1");
+  assert.equal(out.getCase, "1");
+  assert.equal(out.trigger, null);
+  assert.equal(out.custom, "custom");
+  assert.equal(response.headers.get("x-case"), "kept");
+  console.log("Native Headers: names and values validated in C match the Fetch spec for every class of input");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-sqlite-lock.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { Database } from "bun:sqlite";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// A standalone binary (the embedded transport, built by the CLI) opens its SQLite databases in
+// EXCLUSIVE locking mode by default; SB_SQLITE_EXCLUSIVE=0 opts out and =1 is the default. The
+// transport on its own, as sproutd and the broker embed it, stays shared unless the variable is
+// set: native-d1.ts covers that. Needs SB_CLI, a sproutboat-cli checkout linked to this one.
+const handler = `export default {
+  async fetch() {
+    await env.DB.prepare("CREATE TABLE IF NOT EXISTS t (v INTEGER)").run();
+    const row = await env.DB.prepare("PRAGMA locking_mode").first();
+    return Response.json({ mode: row.locking_mode });
+  },
+};`;
+
+const cli = process.env.SB_CLI;
+if (!cli) {
+  console.log("skipped: set SB_CLI to a sproutboat-cli checkout linked to this checkout (it builds the sprout)");
+  process.exit(0);
+}
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = mkdtempSync(join(tmpdir(), "sb-native-sqlite-lock-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+try {
+  const project = join(workdir, "lock");
+  mkdirSync(join(project, "src"), { recursive: true });
+  writeFileSync(join(project, "src/index.js"), handler);
+  writeFileSync(
+    join(project, "sproutboat.jsonc"),
+    JSON.stringify({ name: "lock", main: "src/index.js", compatibility_date: "2026-10-28", d1_databases: ["DB"] }),
+  );
+  const built = Bun.spawnSync(["bun", join(cli, "src/main.ts"), "build", "--standalone", "--target", "host"], {
+    cwd: project,
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  assert.equal(built.exitCode, 0, "the CLI could not build the sprout");
+
+  const run = async (label: string, setting: string | undefined, expected: string) => {
+    const data = join(workdir, `data-${label}`);
+    const base = Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== "SB_SQLITE_EXCLUSIVE"));
+    const env = setting === undefined ? base : { ...base, SB_SQLITE_EXCLUSIVE: setting };
+    const port = freePort();
+    const server = Bun.spawn([join(project, "dist/lock")], {
+      cwd: project,
+      env: { ...env, SB_DATA_DIR: data, PORT: String(port) },
+      stdout: "ignore",
+      stderr: "inherit",
+    });
+    servers.push(server);
+    let response: Response | undefined;
+    for (let attempt = 0; attempt < 100 && !response; attempt++) {
+      try {
+        response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(2000) });
+      } catch {
+        if (server.exitCode !== null) break;
+        await Bun.sleep(100);
+      }
+    }
+    assert(response, `${label}: the compiled handler did not start`);
+    assert.deepEqual(await response.json(), { mode: expected }, label);
+    // Another process can open the database while the binary runs only in shared mode.
+    let other = "";
+    try {
+      const db = new Database(join(data, "d1/DB.sqlite"), { readonly: true });
+      other = String(db.query("SELECT count(*) AS n FROM t").get()?.n);
+      db.close();
+    } catch (error) {
+      other = String(error);
+    }
+    if (expected === "exclusive")
+      assert.match(other, /locked|busy/i, `${label}: a second opener is locked out (${other})`);
+    else assert.equal(other, "0", `${label}: a second opener can read`);
+    server.kill(9);
+    await server.exited;
+  };
+  await run("default", undefined, "exclusive");
+  await run("one", "1", "exclusive");
+  await run("zero", "0", "normal");
+  console.log("standalone SQLite: EXCLUSIVE by default, SB_SQLITE_EXCLUSIVE=0 opts out");
+} finally {
+  for (const server of servers) server.kill(9);
+  rmSync(workdir, { recursive: true, force: true });
+}