@sproutboat/runtime 0.44.0 → 0.46.0

package/test/native-db-table.ts

@@ -0,0 +1,244 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// The handle table of the embedded transport (plan 018 phase 1), compiled directly against the system SQLite:
+// the slot LRU, the single close function, the cache sizing rules, the object-database slot count.
+// A C driver runs one scenario per process (the table is process-global) and prints one JSON line.
+// SB_TEST_SQLITE_DIR=DIR (sqlite3.h and a built sqlite3.o, the amalgamation the host uses) runs it against that instead;
+// SB_DB_TABLE_BENCH=1 also prints the E7 timings (adaptive cache against a fixed 2 MiB).
+const transport = await readFile(new URL("../src/transport-embedded.js", import.meta.url), "utf8");
+const ltxStart = transport.indexOf("// BEGIN LTX NATIVE"),
+  ltxEnd = transport.indexOf("// END LTX NATIVE", ltxStart);
+const tableStart = transport.indexOf("// BEGIN DB TABLE NATIVE"),
+  tableEnd = transport.indexOf("// END DB TABLE NATIVE", tableStart);
+assert(ltxStart > 0 && ltxEnd > ltxStart && tableStart > ltxEnd && tableEnd > tableStart);
+const work = await mkdtemp(join(tmpdir(), "sb-native-dbtable-"));
+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 <errno.h>
+// These four lines are transport-embedded.js's globals above the LTX block: keep them equal.
+#define SB_MAX_DB 64
+static sqlite3* sb_dbs[SB_MAX_DB];
+static char sb_db_names[SB_MAX_DB][256];
+static int sb_db_count = 0;
+${transport.slice(ltxStart, ltxEnd)}
+${transport.slice(tableStart, tableEnd)}
+static char root[512];
+static void path_of(char* out, const char* kind, int i) {
+  // object databases live under /do-sql/CLASS/, D1-style ones under /d1/
+  if (!strcmp(kind, "do")) snprintf(out, 600, "%s/do-sql/C/%064x.sqlite", root, i);
+  else snprintf(out, 600, "%s/d1/db%d.sqlite", root, i);
+}
+static void sql(int idx, const char* q) { char* e = 0; if (sqlite3_exec(sb_dbs[idx], q, 0, 0, &e)) { printf("{\\"error\\":\\"%s: %s\\"}\\n", q, e); exit(1); } }
+static long scalar(int idx, const char* q) { sqlite3_stmt* st; long v = -1; if (!sqlite3_prepare_v2(sb_dbs[idx], q, -1, &st, 0)) { if (sqlite3_step(st) == 100) v = sqlite3_column_int64(st, 0); sqlite3_finalize(st); } return v; }
+static void stats(void) { char b[600]; sb_db_stats(b, sizeof b); printf("{\\"stats\\":%s}\\n", b); }
+static double ms_since(struct timespec* a) { struct timespec b; clock_gettime(CLOCK_MONOTONIC, &b); return ((b.tv_sec - a->tv_sec) * 1e9 + (b.tv_nsec - a->tv_nsec)) / 1e6; }
+int main(int argc, char** argv) {
+  snprintf(root, sizeof root, "%s", argv[1]);
+  const char* scenario = argv[2];
+  char p[600];
+  sb_sqlite_boot();
+  if (!strcmp(scenario, "slots")) { printf("{\\"slots\\":%d,\\"targetKb\\":%ld}\\n", sb_do_sql_open, sb_cache_target_kb); return 0; }
+  if (!strcmp(scenario, "fifty")) {
+    // 50 object databases through the slots: each reads back what it wrote after being closed and reopened
+    int bad = 0, max_open = 0;
+    for (int i = 0; i < 50; i++) {
+      path_of(p, "do", i); int idx = sb_db_for(p); if (idx < 0) { printf("{\\"error\\":\\"open %d\\"}\\n", i); return 1; }
+      sql(idx, "CREATE TABLE IF NOT EXISTS t (v INTEGER)"); char q[64]; snprintf(q, sizeof q, "INSERT INTO t VALUES (%d)", i * 7); sql(idx, q);
+      int open = 0; for (int k = 0; k < sb_db_count; k++) if (sb_dbs[k]) open++; if (open > max_open) max_open = open;
+    }
+    for (int r = 0; r < 2; r++) for (int i = 49; i >= 0; i--) {
+      path_of(p, "do", i); int idx = sb_db_for(p); if (idx < 0 || scalar(idx, "SELECT v FROM t") != i * 7) bad++;
+    }
+    stats(); printf("{\\"bad\\":%d,\\"maxOpen\\":%d}\\n", bad, max_open); return 0;
+  }
+  if (!strcmp(scenario, "txn")) {
+    // a handle inside a transaction is never the one the LRU closes, and do.sql.close refuses it
+    path_of(p, "do", 0); int a = sb_db_for(p); sql(a, "CREATE TABLE t (v)"); sql(a, "BEGIN"); sql(a, "INSERT INTO t VALUES (1)");
+    for (int i = 1; i <= sb_do_sql_open + 3; i++) { path_of(p, "do", i); int idx = sb_db_for(p); if (idx < 0) { printf("{\\"error\\":\\"open %d\\"}\\n", i); return 1; } sql(idx, "CREATE TABLE IF NOT EXISTS t (v)"); }
+    path_of(p, "do", 0); int refused = sb_db_close_path(p); int still = sb_db_for(p) == a;
+    sql(a, "COMMIT"); int closed = sb_db_close_path(p);
+    printf("{\\"refused\\":%d,\\"still\\":%d,\\"closed\\":%d}\\n", refused, still, closed); return 0;
+  }
+  if (!strcmp(scenario, "nowal")) {
+    path_of(p, "do", 5); int idx = sb_db_for(p); sql(idx, "CREATE TABLE t (v)"); for (int i = 0; i < 100; i++) sql(idx, "INSERT INTO t VALUES (1)");
+    char wal[700]; snprintf(wal, sizeof wal, "%s-wal", p); struct stat st; int walBefore = !stat(wal, &st);
+    int closed = sb_db_close_path(p); int walAfter = !stat(wal, &st); snprintf(wal, sizeof wal, "%s-shm", p); int shmAfter = !stat(wal, &st);
+    int again = sb_db_close_path(p);
+    printf("{\\"walBefore\\":%d,\\"closed\\":%d,\\"walAfter\\":%d,\\"shmAfter\\":%d,\\"again\\":%d}\\n", walBefore, closed, walAfter, shmAfter, again); return 0;
+  }
+  if (!strcmp(scenario, "share")) {
+    // opens N D1-style databases (not limited by the object slots) and reports each size
+    int n = atoi(argv[3]); long sum = 0, mx = 0, mn = 1 << 30;
+    for (int i = 0; i < n; i++) { path_of(p, "d1", i); int idx = sb_db_for(p); if (idx < 0) { printf("{\\"error\\":\\"open %d\\"}\\n", i); return 1; } sql(idx, "CREATE TABLE IF NOT EXISTS t (v)"); }
+    for (int i = 0; i < sb_db_count; i++) if (sb_dbs[i]) { sum += sb_cache_kb[i]; if (sb_cache_kb[i] > mx) mx = sb_cache_kb[i]; if (sb_cache_kb[i] < mn) mn = sb_cache_kb[i]; }
+    printf("{\\"n\\":%d,\\"sumKb\\":%ld,\\"maxKb\\":%ld,\\"minKb\\":%ld,\\"shareKb\\":%d}\\n", n, sum, mx, mn, sb_cache_share_kb()); return 0;
+  }
+  if (!strcmp(scenario, "growshrink")) {
+    path_of(p, "d1", 0); int idx = sb_db_for(p); sql(idx, "CREATE TABLE t (v TEXT)");
+    sql(idx, "BEGIN"); for (int i = 0; i < 12000; i++) sql(idx, "INSERT INTO t VALUES (hex(randomblob(100)))"); sql(idx, "COMMIT");
+    int start = sb_cache_kb[idx];
+    for (int i = 0; i < 400; i++) { idx = sb_db_for(p); scalar(idx, "SELECT sum(length(v)) FROM t"); }
+    int grown = sb_cache_kb[idx];
+    for (int i = 1; i < 32; i++) { char q[600]; path_of(q, "d1", i); int j = sb_db_for(q); sql(j, "CREATE TABLE IF NOT EXISTS t (v)"); }
+    long sum = 0; for (int i = 0; i < sb_db_count; i++) if (sb_dbs[i]) sum += sb_cache_kb[i];
+    printf("{\\"start\\":%d,\\"grown\\":%d,\\"after\\":%d,\\"sumKb\\":%ld,\\"targetKb\\":%ld,\\"grow\\":%lu,\\"shrink\\":%lu}\\n", start, grown, sb_cache_kb[0], sum, sb_cache_target_kb, sb_stat_grow, sb_stat_shrink); return 0;
+  }
+  if (!strcmp(scenario, "small")) {
+    // one small D1-style database, a few queries: how much SQLite memory does the worker hold
+    path_of(p, "d1", 0); int idx = sb_db_for(p); sql(idx, "CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    for (int i = 0; i < 40; i++) { char q[100]; snprintf(q, sizeof q, "INSERT INTO t (v) VALUES ('row %d')", i); sql(idx, q); }
+    for (int i = 0; i < 100; i++) { idx = sb_db_for(p); scalar(idx, "SELECT count(*) FROM t"); }
+    stats(); return 0;
+  }
+  if (!strcmp(scenario, "bench")) {
+    // E7 (plan 016's G13): 200 calls of a 20-row feed after a cold open, then three scans of 50 MB
+    path_of(p, "d1", 0); int idx = sb_db_for(p); sql(idx, "CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)");
+    sql(idx, "BEGIN"); for (int i = 0; i < 250000; i++) sql(idx, "INSERT INTO t (v) VALUES (hex(randomblob(100)))"); sql(idx, "COMMIT");
+    sb_db_close_path(p);
+    struct timespec a; double scan[3];
+    idx = sb_db_for(p); clock_gettime(CLOCK_MONOTONIC, &a);
+    for (int i = 0; i < 200; i++) { idx = sb_db_for(p); sqlite3_stmt* st; sqlite3_prepare_v2(sb_dbs[idx], "SELECT id, v FROM t ORDER BY id DESC LIMIT 20", -1, &st, 0); while (sqlite3_step(st) == 100) {} sqlite3_finalize(st); }
+    double feed = ms_since(&a) * 1000 / 200;
+    for (int r = 0; r < 3; r++) { idx = sb_db_for(p); clock_gettime(CLOCK_MONOTONIC, &a); scalar(idx, "SELECT sum(length(v)) FROM t"); scan[r] = ms_since(&a); }
+    printf("{\\"feedUs\\":%.1f,\\"scanMs\\":[%.1f,%.1f,%.1f],\\"cacheKb\\":%d}\\n", feed, scan[0], scan[1], scan[2], sb_cache_kb[idx]); return 0;
+  }
+  if (!strcmp(scenario, "busy")) {
+    path_of(p, "do", 9); int idx = sb_db_for(p); sql(idx, "CREATE TABLE t (v)"); sql(idx, "INSERT INTO t VALUES (1)");
+    sqlite3_stmt* leaked = 0; sqlite3_prepare_v2(sb_dbs[idx], "SELECT v FROM t", -1, &leaked, 0); sqlite3_step(leaked);
+    int first = sb_db_close_path(p); int open = sb_dbs[idx] != 0; unsigned long busy = sb_stat_busy;
+    sqlite3_finalize(leaked); int second = sb_db_close_path(p);
+    printf("{\\"first\\":%d,\\"stillOpen\\":%d,\\"busy\\":%lu,\\"second\\":%d}\\n", first, open, busy, second); return 0;
+  }
+  return 2;
+}
+`;
+await Bun.write(join(work, "driver.c"), source);
+const binary = join(work, "driver");
+const amalgamation = process.env.SB_TEST_SQLITE_DIR;
+const compile = Bun.spawnSync(
+  amalgamation
+    ? [
+        "cc",
+        "-O2",
+        `-I${amalgamation}`,
+        join(work, "driver.c"),
+        join(amalgamation, "sqlite3.o"),
+        "-lm",
+        "-ldl",
+        "-lpthread",
+        "-o",
+        binary,
+      ]
+    : ["cc", "-O1", join(work, "driver.c"), "-lsqlite3", "-o", binary],
+);
+assert.equal(compile.exitCode, 0, compile.stderr.toString());
+
+async function run(scenario: string, env: Record<string, string> = {}, ...extra: string[]) {
+  const dir = await mkdtemp(join(work, "run-"));
+  const p = Bun.spawnSync([binary, dir, scenario, ...extra], { env: { PATH: process.env.PATH ?? "", ...env } });
+  assert.equal(p.exitCode, 0, `${scenario}: ${p.stdout.toString()} ${p.stderr.toString()}`);
+  const lines = p.stdout
+    .toString()
+    .trim()
+    .split("\n")
+    .map((l) => JSON.parse(l));
+  return { lines, dir, last: lines[lines.length - 1] };
+}
+const MB32 = String(32 << 20);
+try {
+  // the slot count: clamp(T / 160 KiB, 8, 48) with T = limit / 8
+  assert.equal((await run("slots", { SB_MEMORY_LIMIT: MB32 })).last.slots, 25);
+  assert.equal((await run("slots", { SB_MEMORY_LIMIT: String(16 << 20) })).last.slots, 12);
+  assert.equal((await run("slots", { SB_MEMORY_LIMIT: String(9 << 20) })).last.slots, 8);
+  assert.equal((await run("slots", { SB_MEMORY_LIMIT: String(1024 << 20) })).last.slots, 48);
+  assert.equal((await run("slots")).last.slots, 48, "no limit: 48 slots");
+  assert.equal((await run("slots", { SB_MEMORY_LIMIT: MB32 })).last.targetKb, 4096);
+
+  // 50 object databases through the slots (plan 013 phase D's "50 objects through 8 slots", without capture)
+  const fifty = await run("fifty", { SB_MEMORY_LIMIT: MB32 });
+  assert.equal(fifty.last.bad, 0);
+  assert(fifty.last.maxOpen <= 25, `at most 25 object databases open, saw ${fifty.last.maxOpen}`);
+  assert.equal(fifty.lines[0].stats.busy, 0);
+  assert(fifty.lines[0].stats.closes >= 25);
+  const eight = await run("fifty", { SB_MEMORY_LIMIT: String(9 << 20) });
+  assert.equal(eight.last.bad, 0);
+  assert(eight.last.maxOpen <= 8);
+
+  // a handle inside a transaction is not closed by the LRU nor by do.sql.close
+  const txn = await run("txn", { SB_MEMORY_LIMIT: String(9 << 20) });
+  assert.deepEqual(txn.last, { refused: -1, still: 1, closed: 1 });
+
+  // a close after a write leaves one clean file: no -wal, no -shm; closing again is a no-op
+  // (macOS's system SQLite keeps an emptied -wal and its -shm after the last close whatever the caller does: there the
+  // test checks the WAL was truncated; the Linux amalgamation, which sproutd and the standalone binary use, deletes both.)
+  const nowal = await run("nowal", { SB_MEMORY_LIMIT: MB32 });
+  assert.equal(nowal.last.walBefore, 1);
+  assert.equal(nowal.last.closed, 1);
+  assert.equal(nowal.last.again, 0);
+  const files = await readdir(join(nowal.dir, "do-sql/C"));
+  if (process.platform === "darwin") {
+    for (const f of files.filter((f) => f.endsWith("-wal")))
+      assert.equal((await stat(join(nowal.dir, "do-sql/C", f))).size, 0, "the WAL was checkpointed and truncated");
+  } else {
+    assert.deepEqual(nowal.last, { walBefore: 1, closed: 1, walAfter: 0, shmAfter: 0, again: 0 });
+    assert.equal(files.length, 1, files.join(","));
+  }
+
+  // the share rule: 256 KiB each up to 16 open, shrinking toward T / n above that; the sum stays under T
+  for (const n of [1, 4, 16, 32]) {
+    const r = (await run("share", { SB_MEMORY_LIMIT: MB32 }, String(n))).last;
+    assert(r.sumKb <= 4096, `n=${n}: ${JSON.stringify(r)}`);
+    assert(r.maxKb <= 256, `n=${n}: starts at 256 KiB, saw ${r.maxKb}`);
+    if (n <= 16) assert.equal(r.minKb, 256, `n=${n}`);
+    else assert(r.maxKb <= Math.max(128, r.shareKb) + 128, `n=${n}: ${JSON.stringify(r)}`);
+  }
+  const unlimited = (await run("share", {}, "32")).last;
+  assert.equal(unlimited.minKb, 256, "no limit: 256 KiB each, no shrinking");
+  // SB_SQLITE_CACHE_MB keeps its old meaning: a fixed size
+  const fixed = (await run("share", { SB_SQLITE_CACHE_MB: "3", SB_MEMORY_LIMIT: MB32 }, "20")).last;
+  assert.equal(fixed.minKb, 3072);
+  assert.equal(fixed.maxKb, 3072);
+
+  // growth on evidence, then shrink when more databases open
+  const gs = (await run("growshrink", { SB_MEMORY_LIMIT: MB32 })).last;
+  assert.equal(gs.start, 256);
+  assert(gs.grown > 256 && gs.grown <= 2048, JSON.stringify(gs));
+  assert(gs.grow > 0 && gs.shrink > 0, JSON.stringify(gs));
+  assert(gs.after <= 256 && gs.sumKb <= gs.targetKb, JSON.stringify(gs));
+
+  // a leaked statement: sqlite3_close says BUSY, the slot stays open and is counted, never close_v2
+  const busy = (await run("busy", { SB_MEMORY_LIMIT: MB32 })).last;
+  assert.deepEqual(busy, { first: -1, stillOpen: 1, busy: 1, second: 1 });
+
+  // one small D1 database: well under 300 KiB of SQLite memory (E7)
+  const small = (await run("small", { SB_MEMORY_LIMIT: MB32 })).last;
+  assert(small.stats.memUsed < 300 * 1024, JSON.stringify(small));
+
+  if (process.env.SB_DB_TABLE_BENCH) {
+    // E7 timing (not an assertion: machines differ): the adaptive cache against a fixed 2 MiB, interleaved
+    for (const [name, env] of [
+      ["fixed 2 MiB", { SB_SQLITE_CACHE_MB: "2" }],
+      ["adaptive", { SB_MEMORY_LIMIT: MB32 }],
+      ["fixed 2 MiB", { SB_SQLITE_CACHE_MB: "2" }],
+      ["adaptive", { SB_MEMORY_LIMIT: MB32 }],
+      ["fixed 2 MiB", { SB_SQLITE_CACHE_MB: "2" }],
+      ["adaptive", { SB_MEMORY_LIMIT: MB32 }],
+    ] as const)
+      console.log(name.padEnd(12), JSON.stringify((await run("bench", env)).last));
+  }
+  console.log("native-db-table: ok");
+} finally {
+  await rm(work, { recursive: true, force: true });
+}

package/test/native-do-evict.ts

@@ -0,0 +1,345 @@
+import assert from "node:assert/strict";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Durable Object eviction (plan 018, compatibility date 2026-11-21) on a standalone binary: an idle object leaves memory after
+// SB_DO_IDLE_MS and its next event constructs it again; the cap, the overloaded error, alarms into evicted objects, pins, the
+// reset on a failed blockConcurrencyWhile and the revoked zombie. These are the first copy of the conformance cases of
+// sproutd's conformance/bindings/do.js (plan 018 phase 4). Needs SB_CLI, a sproutboat-cli checkout linked to this one.
+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);
+}
+const IDLE = 300; // ms; every case waits four times that
+const WAIT = IDLE * 4;
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+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-do-evict-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+const fixture = new URL("./fixtures/do-evict-app.js", import.meta.url).pathname;
+
+function build(label: string, date: string): string {
+  const project = join(workdir, label);
+  mkdirSync(join(project, "src"), { recursive: true });
+  copyFileSync(fixture, join(project, "src/index.js"));
+  writeFileSync(
+    join(project, "sproutboat.jsonc"),
+    JSON.stringify({
+      name: "evict-app",
+      main: "src/index.js",
+      compatibility_date: date,
+      durable_objects: { OBJ: "Obj", SLOW: "Slow", FLAKY: "Flaky" },
+    }),
+  );
+  const built = Bun.spawnSync(["bun", join(cli!, "src/main.ts"), "build", "--standalone", "--target", "host"], {
+    cwd: project,
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  assert.equal(built.exitCode, 0, `${label}: the CLI could not build the sprout`);
+  return join(project, "dist/evict-app");
+}
+
+interface Server {
+  port: number;
+  kill(): Promise<void>;
+  get(path: string): Promise<any>;
+  raw(path: string): Promise<Response>;
+  stderr(): string;
+}
+async function start(binary: string, label: string, env: Record<string, string>, capture = false): Promise<Server> {
+  const port = freePort();
+  const data = join(workdir, `data-${label}`);
+  const proc = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, SB_DATA_DIR: data, PORT: String(port), ...env },
+    stdout: "ignore",
+    stderr: capture ? "pipe" : "inherit",
+  });
+  servers.push(proc);
+  let captured = "";
+  if (capture && proc.stderr instanceof ReadableStream) {
+    const stream = proc.stderr;
+    void (async () => {
+      for await (const chunk of stream) captured += new TextDecoder().decode(chunk);
+    })();
+  }
+  let up = false;
+  for (let attempt = 0; attempt < 100 && !up; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(1000) });
+      up = true;
+    } catch {
+      if (proc.exitCode !== null) break;
+      await sleep(100);
+    }
+  }
+  assert(up, `${label}: the compiled handler did not start`);
+  return {
+    port,
+    stderr: () => captured,
+    raw: (path) => fetch(`http://127.0.0.1:${port}${path}`),
+    get: async (path) => (await fetch(`http://127.0.0.1:${port}${path}`)).json(),
+    kill: async () => {
+      proc.kill(9);
+      await proc.exited;
+    },
+  };
+}
+let ids = 0;
+const fresh = () => `o${Date.now().toString(36)}${ids++}`;
+
+try {
+  const [binary, before] = await Promise.all([
+    Promise.resolve(build("on", "2026-11-21")),
+    Promise.resolve(build("off", "2026-11-20")),
+  ]);
+  const main = await start(binary, "main", { SB_DO_IDLE_MS: String(IDLE) });
+
+  // evictMem: an in-memory counter is 1 again after the idle wait; without the wait it is 2
+  {
+    const id = fresh();
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 1);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2, "no wait: the object stayed");
+    await sleep(WAIT);
+    const after = await main.get(`/via/${id}/mem`);
+    assert.equal(after.mem, 1, "after the idle wait the instance is new");
+    // evictCtor: the constructor count in storage went up by one per wake, not per request
+    assert.equal(after.ctor, 2);
+    for (let i = 0; i < 5; i++) assert.equal((await main.get(`/via/${id}/mem`)).ctor, 2);
+  }
+
+  // evictStorage, evictSql: a key and a row written before the wait are read after it
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/put?k=key&v=value1`);
+    await sleep(WAIT);
+    const got = await main.get(`/via/${id}/get?k=key`);
+    assert.equal(got.k, "value1");
+    assert.deepEqual(got.rows, ["value1"]);
+    assert.equal(got.mem, 0, "a new instance");
+  }
+
+  // evictBusy: a request that sits in the object for several idle waits is not evicted in flight
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/mem`);
+    const held = await main.get(`/via/${id}/hold?ms=${WAIT * 2}`);
+    assert.equal(held.ctor, 1);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2, "same instance after the long request");
+  }
+
+  // evictWaitUntil: a waitUntil task that outlives the response keeps the object, and its write is there afterwards
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/mem`);
+    await main.get(`/via/${id}/waituntil?ms=${WAIT}`);
+    await sleep(IDLE * 2);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2, "kept while the task runs");
+    await sleep(WAIT * 2);
+    const got = await main.get(`/via/${id}/get?k=wu`);
+    assert.equal(got.k, "done");
+    assert.equal(got.mem, 0, "and then it left");
+  }
+
+  // evictTimerPin: a pending setTimeout keeps the object; it leaves after the timer fired and another wait
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/mem`);
+    await main.get(`/via/${id}/timer?ms=${WAIT * 2}`);
+    await sleep(WAIT);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2, "pinned by the timer");
+    await sleep(WAIT * 2 + IDLE);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 1, "gone after the timer fired and another wait");
+  }
+
+  // a never-cleared setInterval pins forever
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/interval`);
+    await sleep(WAIT * 2);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 1, "not evicted: the interval lives");
+    await sleep(WAIT);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2);
+  }
+
+  // evictTxn: a transaction that awaits across the wait commits; the object was not evicted under it
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/mem`);
+    await main.get(`/via/${id}/txn?ms=${WAIT * 2}`);
+    assert.equal((await main.get(`/via/${id}/mem`)).mem, 2);
+    assert.equal((await main.get(`/via/${id}/get?k=t`)).k, 1, "committed");
+  }
+
+  // evictZombie: a promise the handler left running writes after the object was evicted: rejected, key absent
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/zombie?n=1`);
+    await sleep(WAIT);
+    await main.get("/release/1");
+    const result = (await main.get("/zombie-result/1")).result;
+    assert.match(result, /^rejected: .*evicted/, result);
+    assert.equal((await main.get(`/via/${id}/get?k=z`)).k, null, "the zombie's key is absent");
+  }
+
+  // evictAbort: abort() then a call: new instance, storage kept, SQL readable
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/put?k=a&v=1`);
+    await main.get(`/via/${id}/mem`);
+    const aborted = await main.raw(`/via/${id}/abort`);
+    assert.equal(aborted.status, 503);
+    const next = await main.get(`/via/${id}/get?k=a`);
+    assert.equal(next.mem, 0);
+    assert.equal(next.k, "1");
+    assert.deepEqual(next.rows, ["1"]);
+    assert(next.ctor >= 2, "constructed again");
+  }
+
+  // evictBcw: the first event after a wake sees the field the constructor's blockConcurrencyWhile set
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/mem`);
+    await sleep(WAIT);
+    assert.equal((await main.get(`/via/${id}/mem`)).ctor, 2);
+  }
+  // evictBcwThrow: a constructor whose blockConcurrencyWhile rejects once: that call fails, the next constructs again and succeeds
+  {
+    const id = fresh();
+    const first = await main.raw(`/via/${id}/x?cls=Flaky`);
+    assert.equal(first.status, 503, "the first call fails");
+    const second = await main.get(`/via/${id}/x?cls=Flaky`);
+    assert.equal(second.ok, 2, "built again and succeeded");
+  }
+
+  // evictAlarm: an alarm set before the wait fires after it; the constructor ran before alarm(); one run
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/alarm?ms=${WAIT * 2}`);
+    await sleep(WAIT);
+    let log = await main.get(`/via/${id}/alarmlog`);
+    assert.equal(log.runs, 0, "the alarm is not due yet");
+    const ctorBefore = log.ctor;
+    assert.equal(ctorBefore, 2, "the read above woke the evicted object");
+    await sleep(WAIT * 3);
+    log = await main.get(`/via/${id}/alarmlog`);
+    assert.equal(log.runs, 1);
+    assert.equal(
+      log.log[0].ctor,
+      ctorBefore + 1,
+      "the object was evicted again and its constructor ran before alarm()",
+    );
+    assert.equal(log.log[0].retryCount, 0);
+  }
+
+  // evictAlarmRetry: an alarm that throws twice, with a wait between, sees retryCount 0, 1, 2 (the row's count, not the instance's)
+  {
+    const id = fresh();
+    await main.get(`/via/${id}/failalarm?n=2&ms=100`);
+    let log = await main.get(`/via/${id}/alarmlog`);
+    for (let i = 0; i < 40 && log.runs < 3; i++) {
+      await sleep(500);
+      log = await main.get(`/via/${id}/alarmlog`);
+    }
+    assert.deepEqual(
+      log.log.map((r) => r.retryCount),
+      [0, 1, 2],
+    );
+    assert.equal(log.runs, 3);
+  }
+
+  // evictManyAlarms: 40 objects with alarms due at once all run exactly once
+  {
+    const base = fresh();
+    const names = Array.from({ length: 40 }, (_, i) => `${base}-${i}`);
+    await Promise.all(names.map((n) => main.get(`/via/${n}/alarm?ms=1500`)));
+    await sleep(6000);
+    const runs = await Promise.all(names.map(async (n) => (await main.get(`/via/${n}/alarmlog`)).runs));
+    assert.deepEqual(
+      runs,
+      names.map(() => 1),
+    );
+  }
+  await main.kill();
+
+  // capWait, capOverloaded: at most 4 objects awake; 8 short requests all answer; 4 long ones and a fifth: the fifth is overloaded
+  {
+    const capped = await start(binary, "cap", { SB_DO_IDLE_MS: "600000", SB_DO_MAX: "4", SB_DO_WAIT_MS: "800" });
+    const names = Array.from({ length: 8 }, () => fresh());
+    const answers = await Promise.all(names.map((n) => capped.get(`/via/${n}/hold?ms=150`)));
+    assert.equal(answers.length, 8);
+    for (const a of answers) assert.equal(a.error, undefined, JSON.stringify(a));
+    const longs = Array.from({ length: 4 }, () => fresh());
+    const holding = longs.map((n) => capped.get(`/via/${n}/hold?ms=2500`));
+    await sleep(300);
+    const t0 = performance.now();
+    const fifth = await capped.get(`/via/${fresh()}/mem`);
+    const waited = performance.now() - t0;
+    assert.equal(fifth.overloaded, true, JSON.stringify(fifth));
+    assert(waited >= 700, `waited ${Math.round(waited)} ms before the error`);
+    for (const h of await Promise.all(holding))
+      assert.equal(h.error, undefined, "the long requests were not disturbed");
+    // the slots are free again
+    assert.equal((await capped.get(`/via/${fresh()}/mem`)).mem, 1);
+    await capped.kill();
+  }
+
+  // the per-object queue limit: events queued behind one object's gate beyond SB_DO_QUEUE_MAX are overloaded
+  {
+    const queued = await start(binary, "queue", { SB_DO_IDLE_MS: "600000", SB_DO_QUEUE_MAX: "3" });
+    const id = fresh();
+    const calls = await Promise.all(Array.from({ length: 6 }, () => queued.get(`/via/${id}/x?cls=Slow`)));
+    const overloaded = calls.filter((c) => c.overloaded === true).length;
+    const served = calls.filter((c) => c.ready === true).length;
+    assert.equal(served, 3, JSON.stringify(calls));
+    assert.equal(overloaded, 3, JSON.stringify(calls));
+    await queued.kill();
+  }
+
+  // the sweep runs on its own timer: with no further request an idle object still leaves (the counters say so on stderr)
+  {
+    const quiet = await start(binary, "sweep", { SB_DO_IDLE_MS: String(IDLE), SB_DO_STATS: "1" }, true);
+    await quiet.get(`/via/${fresh()}/mem`);
+    await sleep(WAIT);
+    const text = quiet.stderr();
+    assert.match(text, /objects_awake=1 /, text);
+    assert.match(text, /objects_awake=0 .*evicted_idle=1 /, text);
+    await quiet.kill();
+  }
+
+  // SB_DO_IDLE_MS=0 keeps everything resident (the cap still applies)
+  {
+    const resident = await start(binary, "resident", { SB_DO_IDLE_MS: "0" });
+    const id = fresh();
+    await resident.get(`/via/${id}/mem`);
+    await sleep(WAIT);
+    assert.equal((await resident.get(`/via/${id}/mem`)).mem, 2);
+    await resident.kill();
+  }
+
+  // before the compatibility date nothing evicts
+  {
+    const old = await start(before, "before", { SB_DO_IDLE_MS: String(IDLE) });
+    const id = fresh();
+    await old.get(`/via/${id}/mem`);
+    await sleep(WAIT);
+    const after = await old.get(`/via/${id}/mem`);
+    assert.equal(after.mem, 2, "the object stayed resident");
+    assert.equal(after.ctor, 1);
+    await old.kill();
+  }
+  console.log("native-do-evict: ok");
+} finally {
+  for (const server of servers) server.kill(9);
+  rmSync(workdir, { recursive: true, force: true });
+}

package/test/native-lto.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { compileNative } from "./native-compile";
+import { standaloneChannel } from "../../toolchain/src/a21/standalone-channel";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// A standalone server built the way the CLI's host and release builds are: `-flto -O3`. Every other native test
+// compiles without LTO, and that hid a bug on Porffor alpha 23 for macOS arm64: the bridge called the generated
+// main (`p__main__23main`) as a plain C function while the definition is swiftcall, which is harmless across
+// object files and, once LTO sees both, becomes `unreachable`. The binary died with SIGTRAP before it listened.
+// The server must start and answer through every way the host C enters generated code: startup, a request,
+// a timer, a settled promise.
+const handler = `export default {async fetch(request) {
+  const url = new URL(request.url);
+  if (url.pathname === "/timer") { await new Promise((done) => setTimeout(done, 20)); return new Response("timer ok"); }
+  if (url.pathname === "/echo") return new Response("echo:" + (await request.text()));
+  if (url.pathname === "/json") return Response.json({ n: [1, 2, 3], s: "é" });
+  return new Response("hello");
+}};`;
+
+if (standaloneChannel() !== "alpha-23") {
+  // the bug is alpha 23's (PORF_CC); alpha 22 has no swiftcall and alpha 19 builds through the compiler's own native build
+  console.log(`SKIPPED: the -flto check is for the alpha-23 channel, not ${standaloneChannel()}`);
+  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 = await mkdtemp(join(tmpdir(), "sb-native-lto-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  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, "lto.generated.js");
+  const binary = join(workdir, "lto-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+
+  await compileNative({ generated, binary, dir: workdir, flto: true, optimize: 3 });
+
+  const port = freePort();
+  server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, `the -flto -O3 binary did not start (exit ${server.exitCode}, signal ${server.signalCode})`);
+  const base = `http://127.0.0.1:${port}`;
+  assert.equal(await (await fetch(`${base}/`)).text(), "hello");
+  assert.equal(await (await fetch(`${base}/timer`)).text(), "timer ok");
+  assert.equal(await (await fetch(`${base}/echo`, { method: "POST", body: "abc" })).text(), "echo:abc");
+  assert.deepEqual(await (await fetch(`${base}/json`)).json(), { n: [1, 2, 3], s: "é" });
+  assert.equal(server.exitCode, null, "the server stayed up");
+  console.log("A -flto -O3 standalone build starts and answers: startup, request, timer, promise, body");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}