@sproutboat/runtime 0.34.5 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @sproutboat/runtime
 
+## 0.36.0
+
+### Minor Changes
+
+- 7a9c1f9: `AsyncLocalStorage` (`import { AsyncLocalStorage } from "node:async_hooks"`, once the CLI maps the import), as Workers has it: `run`, `exit`, `getStore` and the static `snapshot`. `enterWith` and `disable` throw, as there. The static `bind` is not provided: Porffor compiles a `.bind(` call on a function value to `Function.prototype.bind`, so use `snapshot()`. The toolchain patches Porffor's job queue and timers to carry one current-context value: a promise reaction (then, await, a coroutine resume, a native response callback) and a timer record it when they are created and set it when they run, so the store follows a request across awaits, microtasks, timers, intervals, async fetch and WebSocket callbacks and `ctx.waitUntil`, and requests interleaved in one process never see each other's. Cost: a reaction is 56 bytes, not 40, and each job does one load. The context is only ever set by `AsyncLocalStorage`. Nothing an existing app observes changes, so there is no new compatibility date: `node:async_hooks` did not work at any date before (the import built and `new AsyncLocalStorage()` threw). New native test `test:native-async-local-storage` (needs `SB_CLI`).
+- a68d923: `x-sb-cpu-ms` is per request when requests interleave in one process. A request is charged the thread CPU time of the slices in which it ran (the toolchain's async context carries a request id through awaits, reactions and timers, and the clock is read only when the running request changes, so a request that runs alone costs two reads). Before, the stamp was the process CPU delta across the handler, which is right only for a handler that answers synchronously, so an async handler was never stamped. From compatibility date `2026-11-02` an async handler is stamped too (its response is a string with no Set-Cookie, as for a sync one); earlier dates still send no stamp for an async handler. A synchronous handler's stamp is now thread time, which leaves out the egress threads. New native test `test:native-cpu-requests`: a 200 ms spinner among eight waiters is charged its 200 ms and the waiters under 60 ms, two spinners are each charged their own, and the date gate.
+
+## 0.35.0
+
+### Minor Changes
+
+- 7f5e87b: A standalone binary now opens its SQLite databases in `PRAGMA locking_mode=EXCLUSIVE` by default, with the page cache at 2 MB (`cache_size=-2000`, unchanged). The lock is taken once and held, so a transaction no longer takes and releases file locks around itself, and the WAL index lives in heap memory instead of a shared `-shm` file. The cost: no other process can open the database while the binary runs, so the `sqlite3` shell, `sproutboat kv/d1 --local --data-dir` against a running binary, and the several-copies-behind-`SO_REUSEPORT` recipe do not work on a live binary. Set `SB_SQLITE_EXCLUSIVE=0` to opt out and keep shared locking. A database under LTX replication is never opened exclusive.
+  
+  The default belongs to the standalone binary only: the toolchain's native server shim sets `SB_SQLITE_EXCLUSIVE=1` at startup unless the variable is already set. The embedded transport itself reads only `SB_SQLITE_EXCLUSIVE` (`1` is exclusive, anything else is shared), so sproutd and the broker keep shared locking unless an operator sets it.
+  
+  `SB_SQLITE_CACHE_MB=<n>` (1 to 4096) sets each database's page cache in MiB; unset it stays at 2 MB.
+
+### Patch Changes
+
+- 2c9d885: A strict D1 query in a standalone binary does less around SQLite. It skips the generic dispatch (a request object, a walk down the op list, a result object), a statement is a class instead of an object with five closures, `raw()` and `first()` no longer build the `meta` they throw away (two clock reads), the transaction-keyword check reads character codes instead of compiling a regular expression on every query, and the column names, change count and row id come back as JavaScript values built in C instead of as JSON text that is written, parsed and discarded. Replies, errors and `meta` are unchanged.
+- 004b8e7: A request's fixed cost in a native sprout drops five items. The CPU stamp and the streamed-body probe come back as numbers instead of formatted and parsed text (a `printf` and a `parseFloat` each, per request). The ingress reads of `x-sb-trigger` and `x-sb-remote-addr` scan the stored header names instead of validating and lowercasing a name for each, and the three `x-sb-` names the runtime strips are looked for in one pass. `SB_EDGE_TOKEN` is read once. `Headers` checks a name and a value in C and only falls back to its regular expression for a name it cannot judge there, so `get`, `has`, `set`, `append` and `new Response(body, { headers })` stop compiling that expression on every call. Behavior is unchanged.
+- 4213ed7: A standalone binary stops mapping and unmapping 88 KiB for every statement that builds a temporary table. SQLite allocates 20 pages in one block for each page cache it creates, and `INSERT ... RETURNING` (and any sort that spills to a temporary table) creates one, so each such statement cost an `mmap` and an `munmap`. The runtime now sets the initial page-cache allocation to 0 before SQLite starts, so a cache takes its pages one at a time as it grows. Query results and the main database's cache size are unchanged.
+
 ## 0.34.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.34.5",
+  "version": "0.36.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/d1-shim.test.js

@@ -64,7 +64,9 @@ for (const date of ["2026-09-28", "2026-10-24"]) {
   test(`${date}: batch() is one transaction`, async () => {
     const DB = fresh(date);
     await DB.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
-    expect(await failure(() => DB.batch([DB.prepare("INSERT INTO t VALUES (1)"), DB.prepare("INSERT INTO t VALUES (1)")]))).toMatch(/UNIQUE/);
+    expect(
+      await failure(() => DB.batch([DB.prepare("INSERT INTO t VALUES (1)"), DB.prepare("INSERT INTO t VALUES (1)")])),
+    ).toMatch(/UNIQUE/);
     expect(await DB.prepare("SELECT count(*) AS n FROM t").first("n")).toBe(0);
   });
 }
@@ -85,13 +87,23 @@ test("before 2026-10-24: synchronous, lenient, no foreign keys, BLOBs as one cha
 
 test("from 2026-10-24: D1's parameter rules", async () => {
   const DB = fresh("2026-10-24");
-  expect(caught(() => DB.prepare("SELECT ?1").bind(undefined))).toBe("D1_TYPE_ERROR: Type 'undefined' not supported for value 'undefined'");
-  expect(caught(() => DB.prepare("SELECT ?1").bind({ a: 1 }))).toBe("D1_TYPE_ERROR: Type 'object' not supported for value '[object Object]'");
-  expect(caught(() => DB.prepare("SELECT ?1").bind(10n))).toBe("D1_TYPE_ERROR: Type 'bigint' not supported for value '10'");
+  expect(caught(() => DB.prepare("SELECT ?1").bind(undefined))).toBe(
+    "D1_TYPE_ERROR: Type 'undefined' not supported for value 'undefined'",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").bind({ a: 1 }))).toBe(
+    "D1_TYPE_ERROR: Type 'object' not supported for value '[object Object]'",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").bind(10n))).toBe(
+    "D1_TYPE_ERROR: Type 'bigint' not supported for value '10'",
+  );
   expect(await failure(() => DB.prepare("SELECT ?1, ?2").bind(1).all())).toBe(WRONG_COUNT);
   expect(await failure(() => DB.prepare("SELECT ?1").bind(1, 2).all())).toBe(WRONG_COUNT);
   expect(await failure(() => DB.prepare("SELECT ?1").all())).toBe(WRONG_COUNT);
-  expect(await DB.prepare("SELECT ?1 AS a, ?1 AS b, ?2 AS c").bind("x", true).first()).toEqual({ a: "x", b: "x", c: 1 });
+  expect(await DB.prepare("SELECT ?1 AS a, ?1 AS b, ?2 AS c").bind("x", true).first()).toEqual({
+    a: "x",
+    b: "x",
+    c: 1,
+  });
 });
 
 test("from 2026-10-24: foreign keys, BLOBs as byte arrays, D1's error text", async () => {
@@ -104,18 +116,25 @@ test("from 2026-10-24: foreign keys, BLOBs as byte arrays, D1's error text", asy
   expect(await failure(() => DB.prepare("INSERT INTO p VALUES (1)").run())).toBe(
     "D1_ERROR: UNIQUE constraint failed: p.id: SQLITE_CONSTRAINT (extended: SQLITE_CONSTRAINT_PRIMARYKEY)",
   );
-  expect(await failure(() => DB.prepare("SELECT * FROM nope").all())).toBe("D1_ERROR: no such table: nope: SQLITE_ERROR");
+  expect(await failure(() => DB.prepare("SELECT * FROM nope").all())).toBe(
+    "D1_ERROR: no such table: nope: SQLITE_ERROR",
+  );
   expect(await DB.prepare("SELECT x'00ff' AS b").first("b")).toEqual([0, 255]);
 });
 
 test("from 2026-10-24: every query method returns a Promise", async () => {
   const DB = fresh("2026-10-24");
   const s = DB.prepare("SELECT 41 AS a");
-  for (const p of [s.all(), s.run(), s.first(), s.raw(), DB.batch([s]), DB.exec("SELECT 1"), DB.dump().catch(() => 0)]) expect(p).toBeInstanceOf(Promise);
+  for (const p of [s.all(), s.run(), s.first(), s.raw(), DB.batch([s]), DB.exec("SELECT 1"), DB.dump().catch(() => 0)])
+    expect(p).toBeInstanceOf(Promise);
   expect(await s.first("a").then((a) => a + 1)).toBe(42);
   expect(await Promise.all([s.first("a"), DB.prepare("SELECT 2 AS a").first("a")])).toEqual([41, 2]);
   // Errors reject rather than throw: .catch() sees them.
-  expect(await DB.prepare("SELEC 1").all().catch((e) => e.message)).toMatch(/^D1_ERROR: near "SELEC": syntax error/);
+  expect(
+    await DB.prepare("SELEC 1")
+      .all()
+      .catch((e) => e.message),
+  ).toMatch(/^D1_ERROR: near "SELEC": syntax error/);
 });
 
 test("from 2026-10-24: results, meta, raw() and first() as in workerd", async () => {
@@ -123,16 +142,42 @@ test("from 2026-10-24: results, meta, raw() and first() as in workerd", async ()
   await DB.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)");
   const inserted = await DB.prepare("INSERT INTO t (name) VALUES (?), (?)").bind("one", "two").run();
   expect(Object.keys(inserted).sort()).toEqual(["meta", "results", "success"]);
-  expect(Object.keys(inserted.meta).sort()).toEqual(["changed_db", "changes", "duration", "last_row_id", "rows_read", "rows_written", "served_by", "size_after"]);
-  expect([inserted.meta.changes, inserted.meta.last_row_id, inserted.meta.changed_db, inserted.meta.rows_written]).toEqual([2, 2, true, 2]);
+  expect(Object.keys(inserted.meta).sort()).toEqual([
+    "changed_db",
+    "changes",
+    "duration",
+    "last_row_id",
+    "rows_read",
+    "rows_written",
+    "served_by",
+    "size_after",
+  ]);
+  expect([
+    inserted.meta.changes,
+    inserted.meta.last_row_id,
+    inserted.meta.changed_db,
+    inserted.meta.rows_written,
+  ]).toEqual([2, 2, true, 2]);
   const read = await DB.prepare("SELECT id, name FROM t ORDER BY id").all();
   expect([read.meta.changes, read.meta.changed_db, read.meta.rows_written]).toEqual([0, false, 0]);
-  expect(await DB.prepare("SELECT id, name FROM t ORDER BY id").raw()).toEqual([[1, "one"], [2, "two"]]);
-  expect(await DB.prepare("SELECT id, name FROM t ORDER BY id").raw({ columnNames: true })).toEqual([["id", "name"], [1, "one"], [2, "two"]]);
+  expect(await DB.prepare("SELECT id, name FROM t ORDER BY id").raw()).toEqual([
+    [1, "one"],
+    [2, "two"],
+  ]);
+  expect(await DB.prepare("SELECT id, name FROM t ORDER BY id").raw({ columnNames: true })).toEqual([
+    ["id", "name"],
+    [1, "one"],
+    [2, "two"],
+  ]);
   expect(await DB.prepare("SELECT id FROM t WHERE id > 9").raw({ columnNames: true })).toEqual([["id"]]);
-  expect(await DB.prepare("SELECT 1 AS a, 2 AS a").raw({ columnNames: true })).toEqual([["a", "a"], [1, 2]]);
+  expect(await DB.prepare("SELECT 1 AS a, 2 AS a").raw({ columnNames: true })).toEqual([
+    ["a", "a"],
+    [1, 2],
+  ]);
   expect((await DB.prepare("SELECT 1 AS a, 2 AS a").all()).results).toEqual([{ a: 2 }]);
-  expect(await failure(() => DB.prepare("SELECT id FROM t").first("nope"))).toBe("D1_COLUMN_NOTFOUND: Column not found (nope)");
+  expect(await failure(() => DB.prepare("SELECT id FROM t").first("nope"))).toBe(
+    "D1_COLUMN_NOTFOUND: Column not found (nope)",
+  );
   expect(await DB.prepare("SELECT id FROM t WHERE id > 9").first("nope")).toBeNull();
 });
 
@@ -140,15 +185,74 @@ test("from 2026-10-24: empty SQL, transactions, exec() and sessions as in worker
   const DB = fresh("2026-10-24");
   expect(await failure(() => DB.prepare("").all())).toBe(NO_STATEMENTS);
   expect(await failure(() => DB.batch([]))).toBe(NO_STATEMENTS);
-  expect(await failure(() => DB.prepare("BEGIN TRANSACTION").run())).toMatch(/^D1_ERROR: To execute a transaction, please use the state\.storage\.transaction\(\)/);
+  expect(await failure(() => DB.prepare("BEGIN TRANSACTION").run())).toMatch(
+    /^D1_ERROR: To execute a transaction, please use the state\.storage\.transaction\(\)/,
+  );
   expect(await failure(() => DB.prepare("savepoint x").run())).toMatch(/^D1_ERROR: To execute a transaction/);
   const done = await DB.exec("CREATE TABLE t (id INTEGER)\nINSERT INTO t VALUES (1);\n\nINSERT INTO t VALUES (2);\n");
   expect([done.count, Number.isFinite(done.duration)]).toEqual([3, true]);
   expect(await DB.exec("SELECT 1").then((r) => r.count)).toBe(1);
-  expect(await failure(() => DB.exec("INSERT INTO t VALUES (3);\nSELEC 2"))).toMatch(/^D1_EXEC_ERROR: Error in line 2: SELEC 2: near "SELEC": syntax error/);
+  expect(await failure(() => DB.exec("INSERT INTO t VALUES (3);\nSELEC 2"))).toMatch(
+    /^D1_EXEC_ERROR: Error in line 2: SELEC 2: near "SELEC": syntax error/,
+  );
   expect(await DB.prepare("SELECT count(*) AS n FROM t").first("n")).toBe(2);
   const session = DB.withSession("first-unconstrained");
   expect(await session.prepare("SELECT count(*) AS n FROM t").first("n")).toBe(2);
   expect(session.getBookmark()).toBeNull();
   expect(await session.batch([session.prepare("SELECT 1 AS a")]).then((r) => r[0].results)).toEqual([{ a: 1 }]);
 });
+
+// __sbD1IsTransaction replaced `/^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text)`.
+test("a statement is a transaction keyword exactly as the regular expression it replaced said", () => {
+  // oxlint-disable-next-line no-function-constructor -- the prelude is prepended as text in production too
+  const { isTx } = new Function("Porffor", `${source}\nreturn { isTx: __sbD1IsTransaction };`)({ c: () => "" });
+  const old = (text) => /^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text);
+  const cases = [
+    "BEGIN",
+    "begin",
+    "Begin TRANSACTION",
+    "begin;",
+    "BEGIN\n",
+    "commit",
+    "COMMIT;",
+    "end",
+    "END TRANSACTION",
+    "rollback to x",
+    "ROLLBACK",
+    "savepoint x",
+    "SAVEPOINT\tx",
+    "release x",
+    "RELEASE",
+    "beginning",
+    "begin_x",
+    "begin1",
+    "ending",
+    "endx",
+    "ender",
+    "committed",
+    "rollbacks",
+    "savepoints",
+    "released",
+    "select 1",
+    "SELECT begin FROM t",
+    "insert into t values (1)",
+    "be",
+    "en",
+    "e",
+    "",
+    "BEGINX",
+    "begin-",
+    "end(",
+    "end.",
+    "release@",
+    "commité",
+    "xbegin",
+    " begin",
+    "savepoint",
+    "savepointx",
+    "rollback_",
+    "ROLLBACKĀ",
+    "bégin",
+  ];
+  for (const text of cases) expect([text, isTx(text)]).toEqual([text, old(text)]);
+});