@sproutboat/runtime 0.31.0 → 0.33.0

package/src/queues.test.js

@@ -0,0 +1,159 @@
+import { afterEach, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+
+// Queues from compatibility date 2026-10-31 (producer checks and content types, the
+// consumer's message and batch, first-call-wins, retry settings), against a fake transport.
+const source = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
+// oxlint-disable-next-line no-function-constructor -- the prelude is prepended as text in production too
+const load = new Function(
+  "Porffor",
+  `var __sbCall = (text) => globalThis.__sbTestCall(text);\n${source}\nreturn { install: __sbInstallBindings, run: __sbRunQueueBatch };`,
+);
+const { install, run } = load({ c: () => "" });
+
+let sent = [];
+globalThis.__sbTestCall = (text) => {
+  const req = JSON.parse(text);
+  sent.push(req);
+  return JSON.stringify({ ok: true, metrics: { backlogCount: 1, backlogBytes: 7, oldestMessageTimestamp: 1000 } });
+};
+afterEach(() => {
+  sent = [];
+});
+
+const bindings = {
+  queues: ["QUEUE", "DLQ"],
+  queueConfig: [
+    { binding: "QUEUE", queue: "q", maxRetries: 3, deadLetterQueue: "dlq" },
+    { binding: "DLQ", queue: "dlq" },
+  ],
+};
+const env = (compat) => {
+  globalThis.__sbCompat = compat;
+  const target = {};
+  install(target, bindings);
+  return target;
+};
+const ctx = { waitUntil() {} };
+
+test("2026-10-31: send() returns a promise of the backlog and keeps the content type", async () => {
+  const { QUEUE } = env("2026-10-31");
+  const result = QUEUE.send("123");
+  expect(result).toBeInstanceOf(Promise);
+  expect(await result).toEqual({
+    metadata: { metrics: { backlogCount: 1, backlogBytes: 7, oldestMessageTimestamp: 1000 } },
+  });
+  expect(sent[0].body).toBe('#sbq1:json:"123"');
+  await QUEUE.send("plain", { contentType: "text" });
+  await QUEUE.send(new Uint8Array([7, 8]), { contentType: "bytes" });
+  await QUEUE.send(new Map([[1, 2]]), { contentType: "v8" });
+  expect(sent.map((r) => r.body.split(":")[1])).toEqual(["json", "text", "bytes", "v8"]);
+});
+
+test("2026-10-31: send() and sendBatch() reject what workerd rejects", async () => {
+  const { QUEUE } = env("2026-10-31");
+  const error = (p) =>
+    p.then(
+      () => "accepted",
+      (e) => e.name + ": " + e.message,
+    );
+  expect(await error(QUEUE.send(undefined))).toBe("TypeError: Message body cannot be undefined");
+  expect(await error(QUEUE.send({ b: 1n }))).toBe("TypeError: Do not know how to serialize a BigInt");
+  expect(await error(QUEUE.send({}, { contentType: "text" }))).toBe(
+    'TypeError: Content Type "text" requires a value of type string, but received: object',
+  );
+  expect(await error(QUEUE.send("x", { contentType: "xml" }))).toBe(
+    "TypeError: Unsupported queue message content type: xml",
+  );
+  expect(await error(QUEUE.send("x".repeat(128 * 1024 + 1)))).toStartWith("Error: ");
+  expect(await error(QUEUE.sendBatch([]))).toBe("TypeError: sendBatch() requires at least one message");
+  expect(await error(QUEUE.sendBatch({ body: 1 }))).toStartWith("TypeError: Failed to execute 'sendBatch'");
+  expect(await error(QUEUE.sendBatch(Array.from({ length: 101 }, () => ({ body: 1 }))))).toStartWith("Error: ");
+  expect(sent).toEqual([]);
+});
+
+test("before 2026-10-31 send() is unchanged", () => {
+  const { QUEUE } = env("2026-10-29");
+  expect(QUEUE.send("123")).toBeUndefined();
+  expect(sent[0].body).toBe("123");
+});
+
+const message = (id, body, attempts = 1) => ({ id, body, timestamp: 5000, attempts });
+
+test("2026-10-31: message and batch shapes, decoded bodies, and the queue's name", async () => {
+  globalThis.__sbCompat = "2026-10-31";
+  let seen;
+  await run(
+    {
+      queue(batch) {
+        seen = batch;
+      },
+    },
+    {
+      queue: "QUEUE",
+      messages: [message("a", '#sbq1:text:{"a":1}'), message("b", "#sbq1:bytes:0708")],
+      metadata: { metrics: { backlogCount: 2 } },
+    },
+    ctx,
+  );
+  expect(seen.queue).toBe("q");
+  expect(Object.keys(seen).sort()).toEqual(["messages", "metadata", "queue"]);
+  expect(Object.keys(seen.messages[0]).sort()).toEqual(["attempts", "body", "id", "timestamp"]);
+  expect(seen.messages[0].timestamp).toEqual(new Date(5000));
+  expect(seen.messages[0].body).toBe('{"a":1}');
+  expect(new Uint8Array(seen.messages[1].body)).toEqual(new Uint8Array([7, 8]));
+  expect(seen.metadata.metrics.backlogCount).toBe(2);
+});
+
+test("2026-10-31: the first of ack() and retry() wins, and a message's own call beats the batch's", async () => {
+  globalThis.__sbCompat = "2026-10-31";
+  const out = await run(
+    {
+      queue(batch) {
+        batch.messages[0].ack();
+        batch.messages[0].retry();
+        batch.messages[1].retry({ delaySeconds: 7 });
+        batch.retryAll();
+        throw new Error("after the decisions");
+      },
+    },
+    { queue: "QUEUE", messages: [message("a", "1"), message("b", "2"), message("c", "3")] },
+    ctx,
+  );
+  expect(out.ack).toEqual(["a"]);
+  expect(out.retry).toEqual(["b", "c"]);
+  expect(out.delays).toEqual({ b: 7, c: 0 });
+});
+
+test("max_retries: a retry past it goes to the dead letter queue's binding", async () => {
+  globalThis.__sbCompat = "2026-10-31";
+  const out = await run(
+    {
+      queue(batch) {
+        batch.retryAll();
+      },
+    },
+    { queue: "QUEUE", messages: [message("a", "1", 3), message("b", "2", 4)] },
+    ctx,
+  );
+  expect(out.retry).toEqual(["a", "b"]);
+  expect(out.dead).toEqual(["b"]);
+  expect(out.deadLetter).toBe("DLQ");
+});
+
+test("before 2026-10-31 without settings, the outcome has only ack and retry", async () => {
+  globalThis.__sbCompat = "2026-10-29";
+  let legacy;
+  const out = await run(
+    {
+      queue(batch) {
+        legacy = [batch.queue, Object.keys(batch.messages[0]).includes("ack"), batch.messages[0].timestamp];
+        throw new Error("retry all");
+      },
+    },
+    { queue: "DLQ", messages: [message("a", '{"a":1}')] },
+    ctx,
+  );
+  expect(legacy).toEqual(["dlq", true, 5000]);
+  expect(out).toEqual({ ack: [], retry: ["a"] });
+});

package/src/transport-embedded.js

@@ -3700,8 +3700,14 @@ function __sbEnsureSchema() {
   __sbSql(s, "CREATE INDEX IF NOT EXISTS mq_due ON mq (queue, dead, visible_at)", []);
   const mqColumns = __sbSql(s, "PRAGMA table_info(mq)", []).rows;
   let mqClaim = false;
-  for (let i = 0; i < mqColumns.length; i++) if (mqColumns[i][1] === "claim_token") mqClaim = true;
+  let mqSent = false;
+  for (let i = 0; i < mqColumns.length; i++) {
+    if (mqColumns[i][1] === "claim_token") mqClaim = true;
+    if (mqColumns[i][1] === "sent_at") mqSent = true;
+  }
   if (!mqClaim) __sbSql(s, "ALTER TABLE mq ADD COLUMN claim_token TEXT NOT NULL DEFAULT ''", []);
+  // When the message was sent (message.timestamp); 0 for messages queued before the column.
+  if (!mqSent) __sbSql(s, "ALTER TABLE mq ADD COLUMN sent_at INTEGER NOT NULL DEFAULT 0", []);
   __sbSql(
     s,
     "CREATE TABLE IF NOT EXISTS do_storage (cls TEXT NOT NULL, id TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY (cls, id, key))",
@@ -4278,22 +4284,25 @@ function __sbEmbeddedDispatch(msg) {
     // (data loss), and delaySeconds was ignored on both calls.
     const items = op === "queue.send" ? [{ body: msg.body, delaySeconds: msg.delaySeconds }] : msg.messages || [];
     let first = -1;
+    const now = Date.now();
     for (let i = 0; i < items.length; i++) {
       const item = items[i] || {};
       const delay = Math.max(0, Number(item.delaySeconds) || 0) * 1000;
-      const visible = Date.now() + delay;
+      const visible = now + delay;
       if (first < 0 || visible < first) first = visible;
       __sbSql(
         store,
-        "INSERT INTO mq (queue, id, body, visible_at, attempts, dead) VALUES (?1,?2,?3,?4,0,0)",
-        [msg.queue, __sbHex(12), String(item.body), visible],
+        "INSERT INTO mq (queue, id, body, visible_at, attempts, dead, sent_at) VALUES (?1,?2,?3,?4,0,0,?5)",
+        [msg.queue, __sbHex(12), String(item.body), visible, now],
       );
     }
     // B22: on sproutd, the host delivers the batch (waking the app if it sleeps by then).
     if (first >= 0 && __sbLocal !== null && __sbLocal.queues.indexOf(msg.queue) !== -1) __sbHostDue(first);
-    return { ok: true };
+    return msg.metrics ? { ok: true, metrics: __sbQueueBacklog(store, msg.queue) } : { ok: true };
   }
 
+  if (op === "queue.metrics") return { ok: true, metrics: __sbQueueBacklog(store, msg.queue) };
+
   if (op === "do.storage.get") {
     const r = __sbSql(store, "SELECT value FROM do_storage WHERE cls = ? AND id = ? AND key = ?", [
       msg.cls,
@@ -4739,27 +4748,57 @@ function __sbCronMatches(expr, when) {
 
 var __sbLastCronTick = "";
 
-// One delivery pass over the queues this worker consumes: claims up to 10 due messages per
-// queue, hands them to queue() and applies its acks and retries.
+// A queue's backlog as Queues reports it (send() results, batch.metadata): its live
+// messages, their bytes and the oldest one's send time.
+function __sbQueueBacklog(store, queue) {
+  const r = __sbSql(
+    store,
+    "SELECT COUNT(*), COALESCE(SUM(LENGTH(CAST(body AS BLOB))),0), MIN(NULLIF(sent_at,0)) FROM mq WHERE queue=? AND dead=0",
+    [queue],
+  ).rows[0];
+  return { backlogCount: Number(r[0]) || 0, backlogBytes: Number(r[1]) || 0, oldestMessageTimestamp: Number(r[2]) || 0 };
+}
+
+function __sbQueueAttemptCap(settings) {
+  return Math.max(5, (settings.maxRetries !== undefined ? Number(settings.maxRetries) : 3) + 1);
+}
+
+// How long a queue's due messages wait to fill a batch (max_batch_timeout), in ms.
+function __sbQueueWaitMs(binding) {
+  return Math.max(0, Number(__sbQueueSettings(binding).maxBatchTimeout) || 0) * 1000;
+}
+
+// One delivery pass over the queues this worker consumes: claims up to max_batch_size (10)
+// due messages per queue, hands them to queue() and applies its acks and retries. With a
+// max_batch_timeout, a batch smaller than max_batch_size waits until its oldest message
+// has been due that long.
 async function __sbQueuePass(handlers, queues) {
   __sbEnsureSchema();
   const store = __sbStore();
   const now = Date.now();
   for (let q = 0; q < queues.length; q++) {
     const name = queues[q];
+    const settings = __sbQueueSettings(name);
+    const size = Math.min(100, Math.max(1, Number(settings.maxBatchSize) || 10));
+    const wait = __sbQueueWaitMs(name);
     const claim = String(now) + ":" + String(Math.random());
     __sbSql(store, "BEGIN IMMEDIATE", []);
     let due;
     try {
-      __sbSql(store, "UPDATE mq SET dead=1 WHERE queue=? AND visible_at<=? AND attempts>=5", [
+      // A message whose deliveries never came back (the worker died or timed out each time)
+      // stops after 5 attempts, or max_retries + 1 when that is more.
+      __sbSql(store, "UPDATE mq SET dead=1 WHERE queue=? AND visible_at<=? AND attempts>=?", [
         name,
         now,
+        __sbQueueAttemptCap(settings),
       ]);
       due = __sbSql(
         store,
-        "SELECT id,body,attempts FROM mq WHERE queue=? AND dead=0 AND visible_at<=? ORDER BY visible_at LIMIT 10",
-        [name, now],
+        "SELECT id,body,attempts,sent_at,visible_at FROM mq WHERE queue=? AND dead=0 AND visible_at<=? ORDER BY visible_at LIMIT ?",
+        [name, now, size],
       );
+      if (wait > 0 && due.rows.length > 0 && due.rows.length < size && Number(due.rows[0][4]) + wait > now)
+        due = { rows: [] };
       for (let i = 0; i < due.rows.length; i++)
         __sbSql(
           store,
@@ -4776,9 +4815,9 @@ async function __sbQueuePass(handlers, queues) {
     const messages = [];
     for (let i = 0; i < due.rows.length; i++) {
       const row = due.rows[i];
-
-      messages.push({ id: row[0], body: row[1], timestamp: now, attempts: Number(row[2]) + 1 });
+      messages.push({ id: row[0], body: row[1], timestamp: Number(row[3]) || now, attempts: Number(row[2]) + 1 });
     }
+    const metadata = { metrics: __sbQueueBacklog(store, name) };
     // #171 — same ctx.waitUntil as the broker-delivered path, and the same
     // fix for the handler's own promise: `__sbRunQueueBatch` used to be
     // called fire-and-forget here too, so an async `queue()`'s ack/retry
@@ -4789,24 +4828,55 @@ async function __sbQueuePass(handlers, queues) {
         if (p && __sbIsFn(p.then)) __sbTasks.push(p);
       },
     };
-    let result = __sbRunQueueBatch(handlers, { queue: name, messages }, ctx);
+    let result = __sbRunQueueBatch(handlers, { queue: name, messages, metadata }, ctx);
     if (result && __sbIsFn(result.then)) result = await result;
     if (__sbTasks.length) await __sbDrainWaitUntil(__sbTasks);
-    for (let i = 0; i < result.ack.length; i++) {
-      __sbSql(
-        store,
-        "DELETE FROM mq WHERE queue=? AND id=? AND claim_token=? AND visible_at>?",
-        [name, result.ack[i], claim, Date.now()],
-      );
-    }
-    for (let i = 0; i < result.retry.length; i++) {
+    __sbQueueSettle(store, name, claim, result);
+  }
+}
+
+// Applies a batch's outcome to the claimed rows. `dead` (past max_retries) move to the dead
+// letter queue `deadLetter` as new messages, or are marked dead; `delays` gives each retry's
+// delay in seconds (5 when the runtime sends none). A row whose claim expired meanwhile was
+// handed out again and is left alone.
+function __sbQueueSettle(store, name, claim, result) {
+  const now = Date.now();
+  const dead = result.dead || [];
+  const delays = result.delays || null;
+  for (let i = 0; i < dead.length; i++) {
+    if (result.deadLetter)
       __sbSql(
         store,
-        "UPDATE mq SET visible_at=?,claim_token='',dead=CASE WHEN attempts>=5 THEN 1 ELSE 0 END WHERE queue=? AND id=? AND claim_token=? AND visible_at>?",
-        [Date.now() + 5000, name, result.retry[i], claim, Date.now()],
+        "UPDATE mq SET queue=?,visible_at=?,attempts=0,claim_token='',dead=0 WHERE queue=? AND id=? AND claim_token=? AND visible_at>?",
+        [String(result.deadLetter), now, name, dead[i], claim, now],
       );
-    }
+    else
+      __sbSql(store, "UPDATE mq SET dead=1,claim_token='' WHERE queue=? AND id=? AND claim_token=? AND visible_at>?", [
+        name,
+        dead[i],
+        claim,
+        now,
+      ]);
   }
+  for (let i = 0; i < result.ack.length; i++) {
+    __sbSql(
+      store,
+      "DELETE FROM mq WHERE queue=? AND id=? AND claim_token=? AND visible_at>?",
+      [name, result.ack[i], claim, now],
+    );
+  }
+  for (let i = 0; i < result.retry.length; i++) {
+    const id = result.retry[i];
+    if (dead.indexOf(id) !== -1) continue;
+    const delay = delays !== null && delays[id] != null ? Math.max(0, Number(delays[id]) || 0) * 1000 : 5000;
+    __sbSql(
+      store,
+      "UPDATE mq SET visible_at=?,claim_token='',dead=CASE WHEN attempts>=5 AND ?=0 THEN 1 ELSE 0 END WHERE queue=? AND id=? AND claim_token=? AND visible_at>?",
+      [now + delay, delays !== null ? 1 : 0, name, id, claim, now],
+    );
+  }
+  if (result.deadLetter && dead.length && __sbLocal !== null && __sbLocal.queues.indexOf(String(result.deadLetter)) !== -1)
+    __sbHostDue(now);
 }
 
 // One pass over the Durable Object alarms that are due: claims up to 10 and runs alarm().
@@ -4898,6 +4968,17 @@ function __sbHostDue(at) {
   if (__sbLocal !== null && __sbLocal.consumes) __sbHostNote("due " + String(Math.max(0, Math.trunc(Number(at) || 0))));
 }
 
+// When a queue next has a batch to deliver: its earliest visible message, plus the batch
+// timeout unless a whole batch is already there.
+function __sbQueueNextDue(store, queue) {
+  const r = __sbSql(store, "SELECT MIN(visible_at) FROM mq WHERE queue=? AND dead=0", [queue]);
+  const wait = __sbQueueWaitMs(queue);
+  if (wait === 0 || !r.rows.length || r.rows[0][0] == null) return r;
+  const size = Math.min(100, Math.max(1, Number(__sbQueueSettings(queue).maxBatchSize) || 10));
+  const full = __sbSql(store, "SELECT COUNT(*) FROM mq WHERE queue=? AND dead=0 AND visible_at<=?", [queue, Date.now()]);
+  return Number(full.rows[0][0]) >= size ? r : { rows: [[Number(r.rows[0][0]) + wait]] };
+}
+
 // The earliest time something this worker consumes falls due: a message becomes visible
 // (or its claim expires), an alarm is set for, or a failed alarm is retried. -1 for none.
 function __sbNextDue() {
@@ -4911,7 +4992,7 @@ function __sbNextDue() {
   };
   const queues = __sbLocal.queues;
   for (let q = 0; q < queues.length; q++)
-    take(__sbSql(store, "SELECT MIN(visible_at) FROM mq WHERE queue=? AND dead=0", [queues[q]]));
+    take(__sbQueueNextDue(store, queues[q]));
   if (__sbLocal.alarms) {
     take(__sbSql(store, "SELECT MIN(at) FROM do_alarm", []));
     take(__sbSql(store, "SELECT MIN(expires) FROM do_alarm_delivery WHERE attempts<5", []));

package/src/wrap.ts

@@ -58,6 +58,10 @@ export type Bindings = {
   d1: string[];
   r2: string[];
   queues: string[];
+  /** Each queue binding's queue name and consumer settings (`queueSettings` in
+   *  @sproutboat/config). Absent from older artifacts: every queue is then named by its
+   *  binding, with the default settings. */
+  queueConfig?: QueueSettings[];
   analytics: string[];
   do: Array<{ binding: string; className: string }>;
   /** #48 — worker-to-worker: binding name -> the project it calls. The hostname
@@ -71,6 +75,17 @@ export type Bindings = {
   assets: string;
 };
 
+/** One queue binding's name and consumer settings; unset settings are absent. */
+export type QueueSettings = {
+  binding: string;
+  queue: string;
+  maxBatchSize?: number;
+  maxBatchTimeout?: number;
+  maxRetries?: number;
+  retryDelay?: number;
+  deadLetterQueue?: string;
+};
+
 export const EMPTY_BINDINGS: Bindings = {
   kv: [],
   secrets: [],
@@ -335,7 +350,21 @@ export function readBindingsFromEnv(): Bindings {
       }
     }
   }
-  return {
+  const queueConfig: QueueSettings[] = [];
+  if (Array.isArray(parsed.queueConfig)) {
+    const num = (v: VarsJson | undefined): v is number => Number(v) === v && Number.isFinite(v) && v >= 0;
+    for (const entry of parsed.queueConfig) {
+      if (!isVarsObject(entry) || !isVarsString(entry.binding) || !isVarsString(entry.queue)) continue;
+      const q: QueueSettings = { binding: entry.binding, queue: entry.queue };
+      if (num(entry.maxBatchSize)) q.maxBatchSize = entry.maxBatchSize;
+      if (num(entry.maxBatchTimeout)) q.maxBatchTimeout = entry.maxBatchTimeout;
+      if (num(entry.maxRetries)) q.maxRetries = entry.maxRetries;
+      if (num(entry.retryDelay)) q.retryDelay = entry.retryDelay;
+      if (isVarsString(entry.deadLetterQueue)) q.deadLetterQueue = entry.deadLetterQueue;
+      queueConfig.push(q);
+    }
+  }
+  const out: Bindings = {
     kv: strings(parsed.kv),
     secrets: strings(parsed.secrets),
     d1: strings(parsed.d1),
@@ -348,4 +377,6 @@ export function readBindingsFromEnv(): Bindings {
     ratelimiters,
     assets: isVarsString(parsed.assets) ? parsed.assets : "",
   };
+  if (queueConfig.length) out.queueConfig = queueConfig;
+  return out;
 }

package/test/native-websockets.ts

@@ -0,0 +1,178 @@
+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";
+
+// WebSockets from compatibility date 2026-10-30: a WebSocketPair whose ends both stay in
+// the worker is plain JavaScript and works on every host; a 101 response needs a host that
+// carries client sockets (sproutd), so a standalone sprout answers it with a 501. Before the
+// date nothing is defined. The answers below are workerd's (1.20260730.1) for the same code.
+const handler = `export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  const tick = () => new Promise((r) => setTimeout(r, 10));
+  if (path === "/shape") return Response.json([typeof WebSocketPair, typeof WebSocket, typeof WebSocketRequestResponsePair, new Response("x").webSocket]);
+  if (path === "/pair") {
+    const [client, server] = Object.values(new WebSocketPair());
+    const log = [];
+    server.accept();
+    client.accept();
+    server.binaryType = "arraybuffer";
+    client.binaryType = "arraybuffer";
+    server.addEventListener("message", (e) => {
+      log.push("s:" + (typeof e.data === "string" ? e.data : "bytes " + new Uint8Array(e.data).join(",")));
+      server.send(typeof e.data === "string" ? "echo:" + e.data : e.data);
+    });
+    client.addEventListener("message", (e) => log.push("c:" + (typeof e.data === "string" ? e.data : "bytes " + new Uint8Array(e.data).join(","))));
+    client.addEventListener("close", (e) => log.push("client close " + e.code + " " + e.reason + " " + e.wasClean));
+    server.addEventListener("close", (e) => log.push("server close " + e.code + " " + e.reason + " " + e.wasClean));
+    client.send("hi");
+    client.send(new Uint8Array([1, 2, 3]));
+    await tick();
+    let badCode = "";
+    try { server.close(999); } catch (e) { badCode = e.name; }
+    client.close(4001, "bye");
+    await tick();
+    let after = "";
+    try { client.send("x"); } catch (e) { after = e.message; }
+    return Response.json({ log, badCode, after, states: [client.readyState, server.readyState] });
+  }
+  if (path === "/blob") {
+    // Binary messages are Blobs unless binaryType says otherwise.
+    const [client, server] = Object.values(new WebSocketPair());
+    server.accept();
+    client.accept();
+    const got = [server.binaryType];
+    server.addEventListener("message", async (e) => got.push(e.data instanceof Blob, Array.from(new Uint8Array(await e.data.arrayBuffer()))));
+    client.send(new Uint8Array([7, 8]));
+    await tick();
+    let reason = "";
+    try { server.close(1000, "x".repeat(124)); } catch (e) { reason = e.name; }
+    return Response.json([...got, reason]);
+  }
+  if (path === "/queued") {
+    // Messages sent before the other end accepts wait for it.
+    const pair = new WebSocketPair();
+    const server = pair[1];
+    const client = pair[0];
+    client.accept();
+    client.send("early");
+    await tick();
+    const got = [];
+    server.addEventListener("message", (e) => got.push(e.data));
+    server.accept();
+    await tick();
+    return Response.json(got);
+  }
+  if (path === "/unaccepted") {
+    const pair = new WebSocketPair();
+    try { pair[0].send("x"); return new Response("sent"); } catch (e) { return new Response(e.name + ": " + e.message); }
+  }
+  if (path === "/upgrade") {
+    const [client, server] = Object.values(new WebSocketPair());
+    server.accept();
+    return new Response(null, { status: 101, webSocket: client });
+  }
+  if (path === "/bad101") {
+    try { new Response(null, { status: 101 }); return new Response("made"); } catch (e) { return new Response(e.name); }
+  }
+  return new Response("no route " + path, { 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-websockets-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native WebSocket 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 start = async (date: string) => {
+    const generated = join(workdir, `ws-${date}.generated.js`);
+    const binary = join(workdir, `ws-${date}`);
+    await writeFile(
+      generated,
+      wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker), {}, undefined, 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, 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);
+    const base = `http://127.0.0.1:${port}`;
+    for (let attempt = 0; attempt < 50; attempt++) {
+      try {
+        await fetch(`${base}/bad101`, { signal: AbortSignal.timeout(500) });
+        return base;
+      } catch {
+        if (server.exitCode !== null) break;
+        await Bun.sleep(100);
+      }
+    }
+    throw new Error("compiled handler did not start");
+  };
+  const [now, before] = await Promise.all([start("2026-10-30"), start("2026-10-29")]);
+
+  assert.deepEqual(await (await fetch(`${now}/shape`)).json(), ["function", "function", "function", null]);
+  assert.deepEqual(await (await fetch(`${before}/shape`)).json(), ["undefined", "undefined", "undefined", null]);
+  console.log("WebSocketPair, WebSocket and WebSocketRequestResponsePair exist from 2026-10-30 only");
+
+  assert.deepEqual(await (await fetch(`${now}/pair`)).json(), {
+    log: [
+      "s:hi",
+      "c:echo:hi",
+      "s:bytes 1,2,3",
+      "c:bytes 1,2,3",
+      "server close 4001 bye true",
+      "client close 4001 bye true",
+    ],
+    badCode: "InvalidAccessError",
+    after: "Can't call WebSocket send() after close().",
+    states: [3, 3],
+  });
+  assert.deepEqual(await (await fetch(`${now}/queued`)).json(), ["early"]);
+  assert.deepEqual(await (await fetch(`${now}/blob`)).json(), ["blob", true, [7, 8], "SyntaxError"]);
+  assert.equal(
+    await (await fetch(`${now}/unaccepted`)).text(),
+    "TypeError: You must call one of accept() or state.acceptWebSocket() on this WebSocket before sending messages.",
+  );
+  console.log("a pair passes text, bytes and close codes, and queues messages until accept()");
+
+  const upgrade = await fetch(`${now}/upgrade`);
+  assert.equal(upgrade.status, 501);
+  assert.equal(await upgrade.text(), "WebSockets are not supported by this host yet");
+  assert.equal(await (await fetch(`${now}/bad101`)).text(), "RangeError");
+  assert.equal(await (await fetch(`${before}/bad101`)).text(), "RangeError");
+  console.log("a standalone sprout answers a 101 response with 501; status 101 needs a WebSocket");
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}