@sproutboat/runtime 0.21.1 → 0.23.0

package/test/native-fetch-request.ts

@@ -0,0 +1,305 @@
+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 { createBroker, listen } from "../../wire/src/broker";
+import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// fetch(Request), fetch(Request, init) and new Request(request, init) on a compiled sprout,
+// through the broker transport, against what workerd does (the platform's
+// tests/service-bindings suite holds workerd's answers). The same handler is compiled at
+// compatibility date 2026-10-23, where Request follows Fetch as workerd does, and at
+// 2026-10-22, where an app keeps the older behaviour: a copied Request shares its body,
+// headers stay mutable and any method name passes.
+const handler = `
+const textStream = (...parts) =>
+  new ReadableStream({
+    start(c) {
+      for (const p of parts) c.enqueue(new TextEncoder().encode(p));
+      c.close();
+    },
+  });
+const attempt = async (step) => {
+  try {
+    return await step();
+  } catch (e) {
+    return e.name + ": " + e.message;
+  }
+};
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const up = url.searchParams.get("up");
+    const echo = async (res) => res.json();
+    if (url.pathname === "/ping") return new Response("pong");
+    if (url.pathname === "/fetch") {
+      const viaRequest = await echo(await fetch(new Request(up + "/echo", { method: "PUT", headers: { "x-from": "request" }, body: "req body" })));
+      const plusInit = await echo(
+        await fetch(new Request(up + "/echo", { method: "PUT", headers: { "x-from": "request" }, body: "req body" }), { method: "PATCH", headers: { "x-from": "init" } }),
+      );
+      const initBody = await echo(await fetch(new Request(up + "/echo", { method: "PUT", body: "req body" }), { body: "init body" }));
+      const stream = await echo(await fetch(new Request(up + "/echo", { method: "POST", body: textStream("in ", "a request"), duplex: "half" })));
+      const initStream = await echo(await fetch(up + "/echo", { method: "POST", body: textStream("in ", "init"), duplex: "half" }));
+      const initRequest = new Request("https://other/", { method: "POST", headers: { "x-from": "init-request" }, body: "init req" });
+      const asInit = { ...(await echo(await fetch(up + "/echo", initRequest))), initUsed: initRequest.bodyUsed };
+      const manual = (await fetch(new Request(up + "/redirect", { redirect: "manual" }))).status;
+      const aborted = await attempt(() => fetch(new Request(up + "/echo", { signal: AbortSignal.abort() })).then((r) => r.status));
+      const once = new Request(up + "/echo", { method: "POST", body: "once" });
+      const first = (await echo(await fetch(once))).body;
+      const usedUp = once.bodyUsed;
+      const again = await attempt(() => fetch(once).then(echo).then((e) => e.body));
+      const getBody = await attempt(() => fetch(up + "/echo", { body: "x" }).then((r) => r.status));
+      return Response.json({ viaRequest, plusInit, initBody, stream, initStream, asInit, manual, aborted, first, usedUp, again, getBody });
+    }
+    if (url.pathname === "/forward") {
+      // The incoming request's raw bytes reach the upstream intact.
+      const copied = await echo(await fetch(new Request(up + "/echo", request)));
+      return Response.json({ copied, incomingUsed: request.bodyUsed });
+    }
+    if (url.pathname === "/request") {
+      const a = new Request("https://peer/a", { method: "POST", headers: { "x-a": "1" }, body: "abc" });
+      const b = new Request(a, { headers: { "x-b": "2" } });
+      const copy = { aUsed: a.bodyUsed, aRead: await attempt(() => a.text()), b: await b.text(), headers: [...b.headers] };
+      const s = new Request("https://peer/s", { method: "POST", body: textStream("tee ", "me"), duplex: "half" });
+      const t = s.clone();
+      const tee = [await t.text(), await s.text()];
+      const controller = new AbortController();
+      const signalled = new Request(new Request("https://peer/", { signal: controller.signal }));
+      controller.abort();
+      const res = await fetch(url.searchParams.get("up") + "/echo");
+      await res.text();
+      return Response.json({
+        copy,
+        tee,
+        signal: [signalled.signal.aborted, new Request("https://peer/").signal.aborted],
+        getBody: await attempt(() => new Request("https://peer/", { body: "" }).method),
+        method: await attempt(() => new Request("https://peer/", { method: "custom" }).method),
+        redirect: await attempt(() => new Request("https://peer/", { redirect: "error" }).redirect),
+        incoming: await attempt(() => (request.headers.set("x-t", "1"), "mutable")),
+        fetched: await attempt(() => (res.headers.set("x-t", "1"), "mutable")),
+        copiedResponse: await attempt(() => (new Response(null, res).headers.set("x-t", "1"), "mutable")),
+        incomingBody: request.body === null ? "none" : typeof request.body,
+      });
+    }
+    return new Response("no route", { 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 upstream = Bun.serve({
+  hostname: "127.0.0.1",
+  port: 0,
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (url.pathname === "/redirect") return new Response(null, { status: 302, headers: { location: "/echo?hop=1" } });
+    const bytes = new Uint8Array(await request.arrayBuffer());
+    let binaryIntact = bytes.length === 256;
+    for (let i = 0; binaryIntact && i < 256; i++) binaryIntact = bytes[i] === i;
+    return Response.json({
+      method: request.method,
+      from: request.headers.get("x-from"),
+      type: request.headers.get("content-type"),
+      body: binaryIntact ? "bytes 0-255" : new TextDecoder().decode(bytes),
+    });
+  },
+});
+const up = `http://127.0.0.1:${upstream.port}`;
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-fetch-request-"));
+const broker = createBroker({
+  db: ":memory:",
+  token: "native-fetch-request",
+  bindings: { ...EMPTY_BINDINGS, resources: {} },
+  egressAllow: ["127.0.0.1"],
+});
+const brokerServer = listen(broker, "127.0.0.1", 0);
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+
+// Compiles the handler at `date` and starts it; resolves to a GET helper for it.
+async function start(porffor: string, node: string, source: string, date: string) {
+  const port = freePort();
+  const generated = join(workdir, `fetch-request-${date}.generated.js`);
+  const binary = join(workdir, `fetch-request-${date}`);
+  await writeFile(generated, wrapNativeFetchHandler(handler, source, {}, EMPTY_BINDINGS, undefined, date));
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stderr] = await Promise.all([compile.exited, new Response(compile.stderr).text()]);
+  assert.equal(exitCode, 0, `Porffor native compile at ${date} failed:\n${stderr}`);
+  const server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: {
+      ...process.env,
+      PORT: String(port),
+      SB_BROKER_PORT: String(brokerServer.port),
+      SB_BROKER_TOKEN: "native-fetch-request",
+    },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  servers.push(server);
+  const call = async (path: string, init?: RequestInit) => {
+    const sep = path.includes("?") ? "&" : "?";
+    const res = await fetch(`http://127.0.0.1:${port}${path}${sep}up=${encodeURIComponent(up)}`, {
+      ...init,
+      signal: AbortSignal.timeout(20_000),
+    });
+    const text = await res.text();
+    assert.equal(res.status, 200, `${date} ${path}: ${text}`);
+    return JSON.parse(text);
+  };
+  for (let i = 0; i < 50; i++) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/ping`);
+      if ((await res.text()) === "pong") return call;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  throw new Error(`compiled handler at ${date} did not start`);
+}
+
+try {
+  const porffor = await ensurePorffor({ cacheRoot: workdir });
+  const node = Bun.which("node");
+  if (!node) throw new Error("native fetch-request test needs node on PATH");
+  const [core, transport] = await Promise.all([
+    readFile(preludePath, "utf8"),
+    readFile(transportPath("broker"), "utf8"),
+  ]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const source = core.replace(TRANSPORT_MARKER, transport);
+  const [strict, legacy] = await Promise.all([
+    start(porffor, node, source, "2026-10-23"),
+    start(porffor, node, source, "2026-10-22"),
+  ]);
+
+  const echo = (method: string, from: string | null, type: string | null, body: string) => ({
+    method,
+    from,
+    type,
+    body,
+  });
+  const plain = "text/plain;charset=UTF-8";
+  const bytes = new Uint8Array(256).map((_, i) => i);
+
+  // From 2026-10-23: fetch() is fetch(new Request(input, init)), as in workerd.
+  assert.deepEqual(await strict("/fetch"), {
+    viaRequest: echo("PUT", "request", plain, "req body"),
+    plusInit: echo("PATCH", "init", null, "req body"),
+    initBody: echo("PUT", null, plain, "init body"),
+    stream: echo("POST", null, null, "in a request"),
+    initStream: echo("POST", null, null, "in init"),
+    asInit: { ...echo("POST", "init-request", plain, "init req"), initUsed: true },
+    manual: 302,
+    aborted: "AbortError: The operation was aborted",
+    first: "once",
+    usedUp: true,
+    again: "TypeError: Cannot reconstruct a Request with a used body.",
+    getBody: "TypeError: Request with a GET or HEAD method cannot have a body.",
+  });
+  assert.deepEqual(await strict("/forward", { method: "POST", body: bytes, headers: { "x-from": "client" } }), {
+    copied: echo("POST", "client", null, "bytes 0-255"),
+    incomingUsed: true,
+  });
+  assert.deepEqual(await strict("/request"), {
+    copy: {
+      aUsed: true,
+      aRead:
+        "TypeError: Body has already been used. It can only be used once. Use tee() first if you need to read it twice.",
+      b: "abc",
+      headers: [["x-b", "2"]],
+    },
+    tee: ["tee me", "tee me"],
+    signal: [true, false],
+    getBody: "TypeError: Request with a GET or HEAD method cannot have a body.",
+    method: "TypeError: Invalid HTTP method string: custom",
+    redirect:
+      'TypeError: Invalid redirect value, must be one of "follow" or "manual" ("error" won\'t be implemented since it does not make sense at the edge; use "manual" and check the response status code).',
+    incoming: "TypeError: Can't modify immutable headers.",
+    fetched: "TypeError: Can't modify immutable headers.",
+    copiedResponse: "mutable",
+    incomingBody: "none",
+  });
+
+  // Before it: the Request's method, headers and body still reach the upstream (fixed at
+  // every date, as are stream bodies and raw bytes), but a Request can be sent twice, a
+  // copy leaves the source readable, and headers, methods and redirect modes are not checked.
+  const old = await legacy("/fetch");
+  assert.deepEqual(
+    {
+      viaRequest: old.viaRequest,
+      plusInit: old.plusInit,
+      stream: old.stream,
+      initStream: old.initStream,
+      manual: old.manual,
+      again: old.again,
+    },
+    {
+      viaRequest: echo("PUT", "request", plain, "req body"),
+      plusInit: echo("PATCH", "init", null, "req body"),
+      stream: echo("POST", null, null, "in a request"),
+      initStream: echo("POST", null, null, "in init"),
+      manual: 302,
+      again: "once",
+    },
+  );
+  assert.deepEqual(await legacy("/forward", { method: "POST", body: bytes, headers: { "x-from": "client" } }), {
+    copied: echo("POST", "client", null, "bytes 0-255"),
+    incomingUsed: false,
+  });
+  const oldRequest = await legacy("/request");
+  assert.deepEqual(
+    {
+      aUsed: oldRequest.copy.aUsed,
+      aRead: oldRequest.copy.aRead,
+      tee: oldRequest.tee,
+      signal: oldRequest.signal,
+      method: oldRequest.method,
+      redirect: oldRequest.redirect,
+      incoming: oldRequest.incoming,
+      fetched: oldRequest.fetched,
+      incomingBody: oldRequest.incomingBody,
+    },
+    {
+      aUsed: false,
+      aRead: "abc",
+      tee: ["tee me", "tee me"],
+      signal: [true, false],
+      method: "CUSTOM",
+      redirect: "error",
+      incoming: "mutable",
+      fetched: "mutable",
+      incomingBody: "object",
+    },
+  );
+
+  console.log(
+    "fetch(Request) and new Request(request, init) follow workerd from 2026-10-23 (body used up, init merging, " +
+      "GET/HEAD bodies, methods, redirect modes, signals, immutable headers); stream bodies, clone() tees and raw bytes at every date; " +
+      "2026-10-22 keeps the older Request semantics",
+  );
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  brokerServer.stop();
+  broker.close();
+  upstream.stop(true);
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-ltx.ts

@@ -0,0 +1,359 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, readdir, rm, writeFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+// Compile the exact inline C used by the embedded transport against SQLite.
+// This tests WAL bytes, crash boundaries and fsync paths without a JS mock.
+const transport = await readFile(new URL("../src/transport-embedded.js", import.meta.url), "utf8");
+const start = transport.indexOf("// BEGIN LTX NATIVE");
+const end = transport.indexOf("// END LTX NATIVE", start);
+assert(start > 0 && end > start);
+const work = await mkdtemp(join(tmpdir(), "sb-native-ltx-"));
+const binary = join(work, "driver");
+const source = `
+#include <sqlite3.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <signal.h>
+#define SB_MAX_DB 16
+${transport.slice(start, end)}
+int main(int argc,char **argv) {
+  if(argc!=2)return 2;sb_ltx_compat=1;if(sb_ltx_register())return 3;
+  char lockpath[1024];snprintf(lockpath,sizeof(lockpath),"%s.ltx.lock",argv[1]);
+  int lock=open(lockpath,O_RDWR|O_CREAT,0600);if(lock<0||flock(lock,LOCK_EX|LOCK_NB))return 4;
+  sqlite3 *db=0;if(sqlite3_open_v2(argv[1],&db,6,"sb-ltx-bounded"))return 5;
+  if(getenv("SB_LTX_TEST_AUTO_VACUUM"))sqlite3_exec(db,"PRAGMA auto_vacuum=INCREMENTAL;",0,0,0);
+  if(sqlite3_exec(db,"PRAGMA journal_mode=WAL;PRAGMA cache_size=-2000;",0,0,0)||sb_ltx_start(0,db,argv[1],lock))return 6;
+  puts("ready");fflush(stdout);sb_ltx_test_armed=1;
+  char *line=0;size_t cap=0;
+  while(getline(&line,&cap,stdin)>0) {
+    if(strncmp(line,":break-position",15)==0){char p[1024];snprintf(p,sizeof(p),"%s.ltx/position.tmp",argv[1]);mkdir(p,0700);puts("0 injected");fflush(stdout);continue;}
+    char *error=0;int rc=sb_ltx_states[0].failed?10:sqlite3_exec(db,line,0,0,&error);
+    if(sb_ltx_after(0))rc=10;
+    printf("%d %s\\n",rc,error?error:sqlite3_errmsg(db));fflush(stdout);sqlite3_free(error);
+  }
+  free(line);sqlite3_close(db);close(lock);return 0;
+}
+`;
+await writeFile(join(work, "driver.c"), source);
+await rm(binary, { force: true });
+const compile = Bun.spawnSync(["cc", "-O2", "-DSB_LTX_TESTING", join(work, "driver.c"), "-lsqlite3", "-o", binary]);
+assert.equal(compile.exitCode, 0, compile.stderr.toString());
+
+// Independent CRC baseline in Bun. This intentionally uses BigInt, unlike C.
+const table: bigint[] = [];
+for (let i = 0; i < 256; i++) {
+  let c = BigInt(i);
+  for (let j = 0; j < 8; j++) c = (c >> 1n) ^ (c & 1n ? 0xd800000000000000n : 0n);
+  table.push(c);
+}
+function crc(data: Uint8Array, init = 0xffffffffffffffffn) {
+  let c = init;
+  for (const b of data) c = table[Number((c ^ BigInt(b)) & 255n)] ^ (c >> 8n);
+  return c;
+}
+const flag = 0x8000000000000000n,
+  mask = 0xffffffffffffffffn;
+function pageCrc(pgno: number, page: Uint8Array) {
+  const p = new Uint8Array(4);
+  new DataView(p.buffer).setUint32(0, pgno);
+  return flag | (crc(page, crc(p)) ^ mask);
+}
+
+async function restore(epoch: string, output: string) {
+  const files = (await readdir(epoch)).filter((n) => n.endsWith(".ltx")).sort();
+  let db = new Uint8Array(0),
+    checksum = 0n,
+    txid = 0n;
+  for (const file of files) {
+    const b = new Uint8Array(await readFile(join(epoch, file)));
+    const v = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    assert.equal(new TextDecoder().decode(b.subarray(0, 4)), "LTX1");
+    const pageSize = v.getUint32(8),
+      commit = v.getUint32(12);
+    assert.equal(v.getBigUint64(16), txid + 1n);
+    assert.equal(v.getBigUint64(40), checksum);
+    const next = new Uint8Array(commit * pageSize);
+    next.set(db.subarray(0, next.length));
+    db = next;
+    let offset = 100,
+      hash = crc(b.subarray(0, 100));
+    const entries = [];
+    for (;;) {
+      const begin = offset,
+        pgno = v.getUint32(offset),
+        flags = v.getUint16(offset + 4);
+      hash = crc(b.subarray(offset, offset + 6), hash);
+      offset += 6;
+      if (!pgno) {
+        assert.equal(flags, 0);
+        break;
+      }
+      assert.equal(flags, 1);
+      assert(pgno <= commit);
+      const size = v.getUint32(offset);
+      hash = crc(b.subarray(offset, offset + 4), hash);
+      offset += 4;
+      const stop = offset + size;
+      assert(stop <= b.length);
+      assert.equal(b[offset++], 0xf0);
+      let literals = 15,
+        byte;
+      do {
+        byte = b[offset++];
+        literals += byte;
+      } while (byte === 255);
+      assert.equal(literals, pageSize);
+      assert.equal(offset + pageSize, stop);
+      const page = b.subarray(offset, stop);
+      db.set(page, (pgno - 1) * pageSize);
+      hash = crc(page, hash);
+      offset = stop;
+      entries.push({ pgno, offset: begin, size: stop - begin });
+    }
+    const indexStart = offset;
+    function varint() {
+      let n = 0n,
+        s = 0n;
+      for (let i = 0; i < 10; i++) {
+        assert(offset < b.length);
+        const c = b[offset++];
+        n |= BigInt(c & 127) << s;
+        if (c < 128) return Number(n);
+        s += 7n;
+      }
+      throw new Error("varint overflow");
+    }
+    for (const entry of entries) {
+      assert.equal(varint(), entry.pgno);
+      assert.equal(varint(), entry.offset);
+      assert.equal(varint(), entry.size);
+    }
+    assert.equal(varint(), 0);
+    assert.equal(v.getBigUint64(offset), BigInt(offset - indexStart));
+    offset += 8;
+    hash = crc(b.subarray(indexStart, offset + 8), hash);
+    checksum = flag;
+    for (let p = 1; p <= commit; p++)
+      checksum = flag | (checksum ^ pageCrc(p, db.subarray((p - 1) * pageSize, p * pageSize)));
+    assert.equal(v.getBigUint64(offset), checksum, file);
+    assert.equal(v.getBigUint64(offset + 8), flag | (hash ^ mask), file);
+    assert.equal(offset + 16, b.length);
+    txid = v.getBigUint64(24);
+  }
+  await writeFile(output, db);
+  return { files: files.length, txid };
+}
+async function run(path: string, sql: string, extra: Record<string, string> = {}) {
+  const child = Bun.spawn([binary, path], {
+    env: { ...process.env, ...extra },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  child.stdin.write(sql);
+  child.stdin.end();
+  const [code, out, error] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  assert.equal(code, 0, error);
+  assert(out.startsWith("ready\n"), out);
+  return out.split("\n").slice(1).filter(Boolean);
+}
+async function stoppedCommit(path: string, phase: string, count = 1) {
+  const child = Bun.spawn([binary, path], {
+    env: { ...process.env, SB_LTX_TEST_STOP: phase, SB_LTX_TEST_COMMIT: String(count) },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const reader = child.stdout.getReader();
+  let text = "";
+  async function line() {
+    while (!text.includes("\n")) {
+      const r = await reader.read();
+      if (r.done) throw new Error("driver exited before ready: " + (await new Response(child.stderr).text()));
+      text += new TextDecoder().decode(r.value);
+    }
+    const n = text.indexOf("\n");
+    const value = text.slice(0, n);
+    text = text.slice(n + 1);
+    return value;
+  }
+  assert.equal(await line(), "ready");
+  const position = await readFile(path + ".ltx/position", "utf8");
+  const epoch = position.split("\n")[1];
+  const sql =
+    count === 2
+      ? "INSERT INTO events VALUES(1,'one'); INSERT INTO events VALUES(2,'two');\n"
+      : "INSERT INTO events VALUES(1,'one');\n";
+  child.stdin.write(sql);
+  child.stdin.flush();
+  let stopped = false;
+  for (let i = 0; i < 200; i++) {
+    const state = Bun.spawnSync(["ps", "-o", "state=", "-p", String(child.pid)]).stdout.toString();
+    if (state.includes("T")) {
+      stopped = true;
+      break;
+    }
+    if (child.exitCode !== null) break;
+    await Bun.sleep(10);
+  }
+  child.kill("SIGKILL");
+  await child.exited;
+  assert(stopped, "did not reach crash boundary " + phase);
+  return epoch;
+}
+
+try {
+  const path = join(work, "test.sqlite");
+  const sql =
+    "CREATE TABLE t(id INTEGER PRIMARY KEY,value TEXT);\n" +
+    Array.from({ length: 100 }, (_, i) => `INSERT INTO t VALUES(${i + 1},'row-${i + 1}');`).join("\n") +
+    "\n";
+  const replies = await run(path, sql);
+  assert.equal(replies.length, 101);
+  assert(
+    replies.every((n) => n.startsWith("0 ")),
+    replies.join("\n"),
+  );
+  const root = path + ".ltx";
+  const epoch = (await readdir(root)).find((n) => n.startsWith("epoch-"));
+  assert(epoch);
+  const restored = join(work, "restored.sqlite");
+  const result = await restore(join(root, epoch), restored);
+  assert.equal(result.files, 102);
+  assert.deepEqual(await readFile(restored), await readFile(path));
+  const db = new Database(restored);
+  assert.equal(db.query("PRAGMA integrity_check").get()?.integrity_check, "ok");
+  db.close();
+  const cleanPosition = await readFile(root + "/position", "utf8");
+  assert(cleanPosition.split("\n")[2].startsWith("C "));
+  const finishedBefore = await readdir(join(root, epoch));
+  for (let n = 0; n < 5; n++) {
+    await run(path, "SELECT 1;\n");
+    assert.equal(await readFile(root + "/position", "utf8"), cleanPosition, "idle restart must not rewrite position");
+    assert.deepEqual(await readdir(join(root, epoch)), finishedBefore, "idle restart must not rewrite a base");
+    assert.equal((await readdir(root)).filter((n) => n.startsWith("epoch-")).length, 1);
+  }
+  // Size alone is not enough: an offline committed change must invalidate a clean marker.
+  const offline = new Database(path);
+  offline.exec("UPDATE t SET value='changed-offline' WHERE id=1");
+  offline.close();
+  await run(path, "SELECT 1;\n");
+  const offlineEpoch = (await readFile(root + "/position", "utf8")).split("\n")[1];
+  assert.notEqual(offlineEpoch, epoch);
+  const offlineRestore = join(work, "offline.sqlite");
+  await restore(join(root, offlineEpoch), offlineRestore);
+  assert.deepEqual(await readFile(offlineRestore), await readFile(path));
+  const bounded = join(work, "bounded.sqlite");
+  const boundedReplies = await run(
+    bounded,
+    "CREATE TABLE t(v BLOB);\nINSERT INTO t VALUES(zeroblob(1000000));\nINSERT INTO t VALUES('small');\n",
+    { SB_LTX_MAX_WAL_BYTES: "131072" },
+  );
+  assert(boundedReplies[1].startsWith("13 "), boundedReplies.join("\n"));
+  assert(boundedReplies[2].startsWith("0 "), boundedReplies.join("\n"));
+  const live = new Database(bounded);
+  assert.equal(live.query("SELECT count(*) n FROM t").get()?.n, 1);
+  assert.equal(live.query("PRAGMA integrity_check").get()?.integrity_check, "ok");
+  live.close();
+  const walStat = await stat(bounded + "-wal").catch(() => null);
+  assert(!walStat || walStat.size <= 131072);
+  const shrinking = join(work, "shrinking.sqlite");
+  const shrinkReplies = await run(
+    shrinking,
+    "CREATE TABLE t(v BLOB);\nBEGIN; INSERT INTO t VALUES(zeroblob(500000)); COMMIT;\nBEGIN; INSERT INTO t VALUES('rolled-back'); ROLLBACK;\nDELETE FROM t;\nPRAGMA incremental_vacuum(10000);\n",
+    { SB_LTX_TEST_AUTO_VACUUM: "1" },
+  );
+  assert(
+    shrinkReplies.every((n) => n.startsWith("0 ")),
+    shrinkReplies.join("\n"),
+  );
+  const shrinkEpoch = (await readFile(shrinking + ".ltx/position", "utf8")).split("\n")[1];
+  const shrinkRestore = join(work, "shrinking-restored.sqlite");
+  await restore(shrinking + ".ltx/" + shrinkEpoch, shrinkRestore);
+  assert.deepEqual(await readFile(shrinking), await readFile(shrinkRestore));
+  assert((await stat(shrinking)).size < 32768, "incremental vacuum should shrink the file");
+  const failure = join(work, "failure.sqlite");
+  const failed = await run(
+    failure,
+    "CREATE TABLE events(id INTEGER PRIMARY KEY,value TEXT);\n:break-position\nINSERT INTO events VALUES(1,'committed-before-error');\nINSERT INTO events VALUES(2,'must-be-rejected');\n",
+  );
+  assert(failed[2].startsWith("10 ") && failed[3].startsWith("10 "), failed.join("\n"));
+  await rm(failure + ".ltx/position.tmp", { recursive: true });
+  await run(failure, "SELECT 1;\n");
+  const failureEpoch = (await readFile(failure + ".ltx/position", "utf8")).split("\n")[1];
+  const failureRestore = join(work, "failure-restored.sqlite");
+  await restore(failure + ".ltx/" + failureEpoch, failureRestore);
+  const failedDb = new Database(failureRestore);
+  assert.equal(failedDb.query("SELECT count(*) n FROM events").get()?.n, 1);
+  failedDb.close();
+  const phases = [
+    "wal-committed",
+    "ltx-written",
+    "ltx-fsynced",
+    "ltx-published",
+    "position-fsynced",
+    "position-published",
+    "before-checkpoint",
+    "after-checkpoint",
+    "checkpoint-record-fsynced",
+    "checkpoint-record-published",
+  ];
+  for (const phase of phases) {
+    const crashPath = join(work, "crash-" + phase + ".sqlite");
+    await run(crashPath, "CREATE TABLE events(id INTEGER PRIMARY KEY,value TEXT);\n");
+    const epoch = await stoppedCommit(crashPath, phase);
+    const before = (await readdir(crashPath + ".ltx/" + epoch)).filter((n) => n.endsWith(".ltx")).length;
+    const oldRestore = join(work, "old-" + phase + ".sqlite");
+    await restore(crashPath + ".ltx/" + epoch, oldRestore);
+    const beforeDb = new Database(oldRestore);
+    assert.equal(beforeDb.query("PRAGMA integrity_check").get()?.integrity_check, "ok");
+    const durableRows = beforeDb.query("SELECT count(*) n FROM events").get()?.n;
+    beforeDb.close();
+    assert.equal(durableRows, before > 2 ? 1 : 0);
+    await run(crashPath, "SELECT 1;\n");
+    const position = (await readFile(crashPath + ".ltx/position", "utf8")).split("\n");
+    if (phase === "position-published" || phase === "before-checkpoint" || phase === "checkpoint-record-published")
+      assert.equal(position[1], epoch, "matching WAL must resume");
+    else assert.notEqual(position[1], epoch, "mismatched position must make a fresh base");
+    const recovered = join(work, "recovered-" + phase + ".sqlite");
+    await restore(crashPath + ".ltx/" + position[1], recovered);
+    const rdb = new Database(recovered);
+    assert.equal(rdb.query("SELECT count(*) n FROM events").get()?.n, 1);
+    assert.equal(rdb.query("PRAGMA integrity_check").get()?.integrity_check, "ok");
+    rdb.close();
+  }
+  const pending = join(work, "pending.sqlite");
+  await run(pending, "CREATE TABLE events(id INTEGER PRIMARY KEY,value TEXT);\n");
+  const pendingEpoch = await stoppedCommit(pending, "wal-committed", 2);
+  await run(pending, "SELECT 1;\n");
+  assert.equal((await readFile(pending + ".ltx/position", "utf8")).split("\n")[1], pendingEpoch);
+  const pendingRestore = join(work, "pending-restored.sqlite");
+  const pendingResult = await restore(pending + ".ltx/" + pendingEpoch, pendingRestore);
+  assert.equal(pendingResult.files, 4); // Base, schema commit and both recovered inserts.
+  const pdb = new Database(pendingRestore);
+  assert.equal(pdb.query("SELECT count(*) n FROM events").get()?.n, 2);
+  assert.equal(pdb.query("PRAGMA integrity_check").get()?.integrity_check, "ok");
+  pdb.close();
+  console.log(
+    "PASS restart: 10 SIGKILL durability boundaries, matching-prefix resume, orphan/missing/reset fallback, pending committed WAL tail captured before serving",
+  );
+  console.log(
+    "PASS native LTX: 102-file chain, independent CRC/index checks, byte-exact restore, integrity, hard WAL ceiling and oversized transaction rollback",
+  );
+} finally {
+  await rm(work, { recursive: true, force: true });
+}