@sproutboat/runtime 0.31.0 → 0.33.0

package/src/native-fetch-prelude.js

@@ -4295,6 +4295,9 @@ int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_
 int porf_native_fetch_read_raw_bytes(jsval value, const char** out_buf, size_t* out_len);
 // B22: set only by sproutd's worker host (native-host-bridge.c, at init); null everywhere else.
 void (*sb_host_note_hook)(const char* text, size_t length) = 0;
+// WebSockets (from 2026-10-30): set only by a host that carries client sockets (sproutd's
+// native-host-bridge.c, at init); null everywhere else. See __sbWsOp for the ops.
+long long (*sb_ws_hook)(int op, unsigned int id, const char* data, size_t length, char* out, size_t cap) = 0;
 
 // --- #133: SHA-2 + HMAC ---------------------------------------------------
 // Standalone links BearSSL, but a deployed sprout does not, and this inline C
@@ -5751,9 +5754,182 @@ function __sbAssetResponse(path, r) {
 // object from compile.ts (a `const`, but mutable); we add the binding accessors
 // to it in place. compile.ts emits `__sbInstallBindings(env, {...})` right after
 // the `const env = {...}` line.
+// Queues from compatibility date 2026-10-31, as Cloudflare documents them:
+// - send() and sendBatch() return Promises of { metadata: { metrics } } (the queue's backlog
+//   after the send) and check their arguments with workerd's errors: a body over 128 KiB, an
+//   empty batch, more than 100 messages or 256 KiB, a batch that isn't iterable;
+// - bodies keep their content type: "json" (the default), "text", "bytes" or "v8" (structured
+//   clone, with the Durable Object storage codec), so a string that looks like JSON arrives as
+//   the same string;
+// - a message is { id, timestamp (a Date: when it was sent), body, attempts } with ack() and
+//   retry({ delaySeconds }) on its prototype; the first of ack() and retry() wins, as a
+//   message's own call wins over ackAll() and retryAll(); a batch has queue (the queue's name),
+//   messages and metadata;
+// - by default a message is retried at once, 3 times, then dropped (or moved to the dead
+//   letter queue); earlier dates wait 5 s and try 5 times.
+// The queue name and consumer settings (bindings.queueConfig, from `queues` in
+// sproutboat.jsonc) apply at every date: they are opt-in.
+function __sbQueuesStrict() {
+  return globalThis.__sbCompat >= "2026-10-31";
+}
+
+// binding -> { binding, queue, maxBatchSize?, maxBatchTimeout?, maxRetries?, retryDelay?, deadLetterQueue? }
+var __sbQueueConf = {};
+// queue name -> the binding that stores it
+var __sbQueueByName = {};
+function __sbQueueSetup(bindings) {
+  const queues = bindings.queues || [];
+  const config = bindings.queueConfig || [];
+  for (let i = 0; i < queues.length; i++) __sbQueueConf[queues[i]] = { binding: queues[i], queue: queues[i] };
+  for (let i = 0; i < config.length; i++)
+    if (config[i] && __sbQueueConf[config[i].binding]) __sbQueueConf[config[i].binding] = config[i];
+  for (let i = 0; i < queues.length; i++) __sbQueueByName[__sbQueueConf[queues[i]].queue] = queues[i];
+}
+function __sbQueueSettings(binding) {
+  return __sbQueueConf[binding] || { binding, queue: binding };
+}
+// Where the queue named `name` is stored: its binding, or "#name" for a dead letter queue
+// this worker doesn't bind (its messages wait there; "#" can't begin a binding name).
+function __sbQueuePart(name) {
+  return __sbQueueByName[name] || "#" + name;
+}
+
+const __sbQueueTag = "#sbq1:";
+const __sbQueueMaxMessage = 128 * 1024;
+const __sbQueueMaxBatch = 256 * 1024;
+
+function __sbQueueBytesOf(value) {
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return null;
+}
+function __sbQueueTypeName(value) {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- workerd's error names the received type
+  return value === null ? "null" : typeof value;
+}
+
+// A body as the stored text "#sbq1:TYPE:PAYLOAD", and its size as Queues counts it.
+function __sbQueueEncode(body, contentType) {
+  const type = contentType === undefined ? "json" : contentType;
+  let payload;
+  let size;
+  if (type === "json") {
+    if (body === undefined) throw new TypeError("Message body cannot be undefined");
+    try {
+      payload = JSON.stringify(body);
+    } catch (error) {
+      if (error instanceof TypeError && /BigInt/i.test(String(error.message)))
+        throw new TypeError("Do not know how to serialize a BigInt");
+      throw error;
+    }
+    if (payload === undefined) throw new TypeError("Message body cannot be undefined");
+    size = new TextEncoder().encode(payload).length;
+  } else if (type === "text") {
+    if (!__sbIsStr(body))
+      throw new TypeError('Content Type "text" requires a value of type string, but received: ' + __sbQueueTypeName(body));
+    payload = body;
+    size = new TextEncoder().encode(body).length;
+  } else if (type === "bytes") {
+    const bytes = __sbQueueBytesOf(body);
+    if (bytes === null)
+      throw new TypeError('Content Type "bytes" requires a value of type ArrayBuffer, but received: ' + __sbQueueTypeName(body));
+    payload = __sbDOHex(bytes);
+    size = bytes.length;
+  } else if (type === "v8") {
+    payload = JSON.stringify(__sbDOPack(body, []));
+    size = new TextEncoder().encode(payload).length;
+  } else throw new TypeError("Unsupported queue message content type: " + type);
+  if (size > __sbQueueMaxMessage)
+    throw new Error("Queue send failed: message is " + size + " bytes, over the limit of " + __sbQueueMaxMessage);
+  return { text: __sbQueueTag + type + ":" + payload, size };
+}
+
+// Reads both formats at every date: tagged (2026-10-31 sends) and the earlier text.
+function __sbQueueDecode(raw) {
+  if (__sbIsStr(raw) && raw.indexOf(__sbQueueTag) === 0) {
+    const rest = raw.slice(__sbQueueTag.length);
+    const colon = rest.indexOf(":");
+    const type = rest.slice(0, colon);
+    const payload = rest.slice(colon + 1);
+    if (type === "text") return payload;
+    if (type === "json") return JSON.parse(payload);
+    if (type === "bytes") return __sbDOUnhex(payload).buffer;
+    if (type === "v8") return __sbDOUnpack(JSON.parse(payload));
+  }
+  return __sbTryParse(raw);
+}
+
+function __sbQueueMetrics(metrics) {
+  const m = metrics || {};
+  const oldest = Number(m.oldestMessageTimestamp) || 0;
+  return {
+    backlogCount: Number(m.backlogCount) || 0,
+    backlogBytes: Number(m.backlogBytes) || 0,
+    // Milliseconds since the epoch, as Cloudflare documents it; none for an empty queue.
+    oldestMessageTimestamp: oldest > 0 ? oldest : undefined,
+  };
+}
+
+function __sbQueueDelay(value) {
+  return value == null ? 0 : Math.max(0, Number(value) || 0);
+}
+
+function __sbMakeQueue(binding) {
+  return {
+    send(body, options) {
+      try {
+        const o = options || {};
+        const encoded = __sbQueueEncode(body, o.contentType);
+        const reply = __sbRpc("queue.send", {
+          queue: binding,
+          body: encoded.text,
+          delaySeconds: __sbQueueDelay(o.delaySeconds),
+          metrics: true,
+        });
+        return Promise.resolve({ metadata: { metrics: __sbQueueMetrics(reply.metrics) } });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    sendBatch(messages, options) {
+      try {
+        if (messages == null || !__sbIsFn(messages[Symbol.iterator]))
+          throw new TypeError("Failed to execute 'sendBatch' on 'WorkerQueue': parameter 1 is not of type 'Sequence'.");
+        const batchDelay = __sbQueueDelay(options && options.delaySeconds);
+        const list = [];
+        let total = 0;
+        for (const m of messages) {
+          const item = m || {};
+          const encoded = __sbQueueEncode(item.body, item.contentType);
+          total += encoded.size;
+          // A message delay of 0 (or none) takes the batch delay, as miniflare does.
+          list.push({ body: encoded.text, delaySeconds: __sbQueueDelay(item.delaySeconds) || batchDelay });
+        }
+        if (list.length === 0) throw new TypeError("sendBatch() requires at least one message");
+        if (list.length > 100) throw new Error("Queue sendBatch failed: " + list.length + " messages, over the limit of 100");
+        if (total > __sbQueueMaxBatch)
+          throw new Error("Queue sendBatch failed: " + total + " bytes, over the limit of " + __sbQueueMaxBatch);
+        const reply = __sbRpc("queue.send_batch", { queue: binding, messages: list, metrics: true });
+        return Promise.resolve({ metadata: { metrics: __sbQueueMetrics(reply.metrics) } });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    metrics() {
+      try {
+        return Promise.resolve(__sbQueueMetrics(__sbRpc("queue.metrics", { queue: binding }).metrics));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+  };
+}
+
 globalThis.__sbInstallBindings = function (target, bindings) {
   if (!target) return;
 
+  __sbQueueSetup(bindings);
+
   for (let i = 0; i < (bindings.kv || []).length; i++) {
     const ns = bindings.kv[i];
     target[ns] = __sbKvStrict() ? __sbMakeKv(ns) : {
@@ -5898,7 +6074,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 
   for (let i = 0; i < (bindings.queues || []).length; i++) {
     const name = bindings.queues[i];
-    target[name] = {
+    target[name] = __sbQueuesStrict() ? __sbMakeQueue(name) : {
       send(body, options) {
         const o = options || {};
         __sbRpc("queue.send", {
@@ -6498,6 +6674,7 @@ function __sbUpstream(op, msg, label, signal, always) {
 // prelude must not replace fetch just by being evaluated.
 globalThis.__sbInstallFetch = function () {
   __sbIngressStreamingSetup();
+  __sbInstallWebSockets();
   globalThis.fetch = function (input, init) {
     let parts;
     try {
@@ -6859,7 +7036,11 @@ function __sbGetDOInstance(cls, idText, idObj) {
         if (p && __sbIsFn(p.then)) __sbTasks.push(p);
       },
     };
+    // The hibernation API, from 2026-10-30 (where WebSocketPair exists).
+    const holder = { inst: null, auto: null };
+    if (__sbWsEnabled()) __sbDOWebSocketState(state, holder);
     inst = new Ctor(state, globalThis.env);
+    holder.inst = inst;
     inst.__sbTasks = __sbTasks;
     inst.__sbGate = gate;
     __sbDOInstances[cacheKey] = inst;
@@ -7841,10 +8022,414 @@ function __sbStreamResponse(response) {
   return response;
 }
 
-async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow) {
+// ---------------------------------------------------------------------------
+// WebSockets, from compatibility date 2026-10-30, as in workerd: WebSocketPair, accept(),
+// send(), close(), message and close events, new Response(null, { status: 101, webSocket })
+// and, for Durable Objects, the hibernation API (__sbDOWebSocketState).
+//
+// A pair whose ends both stay in this worker (a Worker and its Durable Object) is plain
+// JavaScript, so it works on every host. The client end of a 101 response becomes a real
+// socket only on a host that carries it (sproutd: its bridge sets sb_ws_hook); the host
+// then stands in for that end: what the app sends to it goes out, and what the remote
+// client sends arrives as if that end had sent it.
+//
+// __sbWsOp(op, id, data, n), on the host socket `id`:
+//   "o" open one (returns its id, "0" without a host), "t" send text data, "b" send the
+//   bytes in data, "c" close with code n and reason data, "p" poll the next event ("" for
+//   none, else "KIND LENGTH CODE": 0 text, 1 binary, 2 close, 3 connection lost), "i" take
+//   that event's payload into the Uint8Array data, "k" acknowledge n bytes dispatched,
+//   "w" fire timer n when an event arrives, "r" release. Returns a short string.
+// oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
+function __sbWsOp(op, id, data, n) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    const char* __o; size_t __ol; char* __oo = 0;
+    porf_native_fetch_read_value(op, &__o, &__ol, &__oo);
+    char __op = __ol ? __o[0] : 0;
+    if (__oo) free(__oo);
+    const unsigned int __id = id.type == 1 && id.val > 0 ? (unsigned int)id.val : 0;
+    const size_t __n = n.type == 1 && n.val > 0 ? (size_t)n.val : 0;
+    char __r[64]; __r[0] = 0;
+    if (sb_ws_hook) {
+      long long __w = -1;
+      if (__op == 'p') {
+        sb_ws_hook('p', __id, 0, 0, __r, sizeof(__r));
+      } else if (__op == 'i') {
+        char* __at = 0; size_t __cap = 0;
+        if (data.type == 81) {
+          const u32 __ta = (u32)data.val;
+          const int32_t __len = *(int32_t*)(MEM + __ta);
+          if (__len > 0) { __at = (char*)(MEM + *(u32*)(MEM + __ta + 4) + 4); __cap = (size_t)__len; }
+        }
+        __w = sb_ws_hook('i', __id, 0, 0, __at, __cap);
+        snprintf(__r, sizeof(__r), "%lld", __w);
+      } else if (__op == 'b') {
+        const char* __d = 0; size_t __dl = 0;
+        if (porf_native_fetch_read_raw_bytes(data, &__d, &__dl) == 0) __w = sb_ws_hook('b', __id, __d, __dl, 0, 0);
+        snprintf(__r, sizeof(__r), "%lld", __w);
+      } else if (__op == 't' || __op == 'c') {
+        const char* __d; size_t __dl; char* __do = 0;
+        porf_native_fetch_read_value(data, &__d, &__dl, &__do);
+        __w = sb_ws_hook(__op, __id, __d, __dl, 0, __n);
+        if (__do) free(__do);
+        snprintf(__r, sizeof(__r), "%lld", __w);
+      } else {
+        __w = sb_ws_hook(__op, __id, 0, 0, 0, __n);
+        snprintf(__r, sizeof(__r), "%lld", __w);
+      }
+    } else if (__op == 'o') snprintf(__r, sizeof(__r), "0");
+    out = porf_box((f64)porf_native_fetch_alloc_bytestring(__r, strlen(__r)), 195);
+  `;
+  return out;
+}
+
+const __SB_WS_OPEN = 1;
+const __SB_WS_CLOSING = 2;
+const __SB_WS_CLOSED = 3;
+const __sbWsKey = {};
+
+// One end of a WebSocketPair. Events are plain objects with the fields apps read (type,
+// data; code, reason, wasClean), dispatched to on<type> (when assigned) and then to the
+// addEventListener listeners, as workerd does. Binary messages arrive as a Blob unless
+// binaryType is "arraybuffer" (workerd's standard binary type).
+class __SbWebSocket {
+  constructor(key) {
+    // Outbound WebSockets (new WebSocket(url)) are not supported; the CLI refuses them too.
+    if (key !== __sbWsKey) throw new TypeError("WebSocket: only WebSocketPair can make a WebSocket here");
+    this._peer = null;
+    this._accepted = false;
+    this._inbox = [];
+    this._flushing = false;
+    this._listeners = {};
+    this._state = __SB_WS_OPEN;
+    this._closeSent = false;
+    this._closeSeen = false;
+    // The host socket this end stands for (the client end of a 101 response), or 0.
+    this._host = 0;
+    // { holder, tags } once a Durable Object took it with ctx.acceptWebSocket().
+    this._hib = null;
+    this._attachment = undefined;
+    this.binaryType = "blob";
+    this.url = null;
+    this.protocol = "";
+    this.extensions = "";
+  }
+  get readyState() {
+    return this._state;
+  }
+  get bufferedAmount() {
+    return 0;
+  }
+  accept() {
+    if (this._host !== 0) throw new TypeError("Can't accept() a WebSocket that was already used in a response.");
+    if (this._hib !== null) throw new TypeError("Can't accept() a WebSocket that was accepted with acceptWebSocket().");
+    if (this._accepted) return;
+    this._accepted = true;
+    __sbWsSchedule(this);
+  }
+  send(message) {
+    if (!this._accepted && this._hib === null)
+      throw new TypeError("You must call one of accept() or state.acceptWebSocket() on this WebSocket before sending messages.");
+    if (this._closeSent) throw new TypeError("Can't call WebSocket send() after close().");
+    if (this._state === __SB_WS_CLOSED || this._peer === null) return;
+    let event;
+    if (__sbIsStr(message)) event = { kind: 0, data: message };
+    else if (message instanceof ArrayBuffer) event = { kind: 1, data: message.slice(0) };
+    else if (ArrayBuffer.isView(message))
+      event = { kind: 1, data: new Uint8Array(message.buffer, message.byteOffset, message.byteLength).slice().buffer };
+    else event = { kind: 0, data: String(message) };
+    __sbWsDeliver(this._peer, event);
+  }
+  close(code, reason) {
+    if (code !== undefined) {
+      code = Number(code);
+      if (!(code === 1000 || (code >= 3000 && code <= 4999))) throw __sbCryptoError("InvalidAccessError", "Invalid WebSocket close code: " + code + ".");
+    }
+    const text = reason === undefined ? "" : String(reason);
+    if (__sbToBytes(text).length > 123)
+      throw __sbCryptoError("SyntaxError", "WebSocket close reason must not be longer than 123 bytes when UTF-8 encoded.");
+    if (this._closeSent) return;
+    this._closeSent = true;
+    this._state = this._closeSeen ? __SB_WS_CLOSED : __SB_WS_CLOSING;
+    if (this._peer !== null) __sbWsDeliver(this._peer, { kind: 2, code: code === undefined ? 1005 : code, reason: text, clean: true });
+  }
+  addEventListener(type, listener) {
+    if (listener == null) return;
+    const list = this._listeners[type] || (this._listeners[type] = []);
+    for (let i = 0; i < list.length; i++) if (list[i] === listener) return;
+    list.push(listener);
+  }
+  removeEventListener(type, listener) {
+    const list = this._listeners[type];
+    if (!list) return;
+    for (let i = 0; i < list.length; i++) {
+      if (list[i] === listener) {
+        list.splice(i, 1);
+        return;
+      }
+    }
+  }
+  dispatchEvent(event) {
+    __sbWsFire(this, event);
+    return true;
+  }
+  serializeAttachment(value) {
+    this._attachment = value === undefined ? undefined : structuredClone(value);
+  }
+  deserializeAttachment() {
+    return this._attachment === undefined ? null : structuredClone(this._attachment);
+  }
+}
+__SbWebSocket.CONNECTING = 0;
+__SbWebSocket.OPEN = __SB_WS_OPEN;
+__SbWebSocket.CLOSING = __SB_WS_CLOSING;
+__SbWebSocket.CLOSED = __SB_WS_CLOSED;
+__SbWebSocket.READY_STATE_CONNECTING = 0;
+__SbWebSocket.READY_STATE_OPEN = __SB_WS_OPEN;
+__SbWebSocket.READY_STATE_CLOSING = __SB_WS_CLOSING;
+__SbWebSocket.READY_STATE_CLOSED = __SB_WS_CLOSED;
+
+class __SbWebSocketPair {
+  constructor() {
+    const client = new __SbWebSocket(__sbWsKey);
+    const server = new __SbWebSocket(__sbWsKey);
+    client._peer = server;
+    server._peer = client;
+    this[0] = client;
+    this[1] = server;
+  }
+}
+
+class __SbWebSocketRequestResponsePair {
+  constructor(request, response) {
+    if (!__sbIsStr(request) || !__sbIsStr(response)) throw new TypeError("WebSocketRequestResponsePair needs two strings");
+    this.request = request;
+    this.response = response;
+  }
+}
+
+function __sbWsFire(ws, event) {
+  const handler = ws["on" + event.type];
+  if (__sbIsFn(handler)) {
+    try {
+      handler.call(ws, event);
+    } catch (error) {
+      __sbLogUncaught("websocket", error);
+    }
+  }
+  const list = ws._listeners[event.type];
+  if (!list) return;
+  const copy = list.slice();
+  for (let i = 0; i < copy.length; i++) {
+    const fn = copy[i];
+    try {
+      if (__sbIsFn(fn)) fn.call(ws, event);
+      else if (fn && __sbIsFn(fn.handleEvent)) fn.handleEvent(event);
+    } catch (error) {
+      __sbLogUncaught("websocket", error);
+    }
+  }
+}
+
+// An event arrives at `ws`, sent by its peer: to the host when `ws` is a host socket,
+// else into ws's inbox, dispatched once it is accepted.
+function __sbWsDeliver(ws, event) {
+  if (ws._host !== 0) {
+    const id = ws._host;
+    if (event.kind === 0) __sbWsOp("t", id, event.data, 0);
+    else if (event.kind === 1) __sbWsOp("b", id, __sbToBytes(new Uint8Array(event.data)), 0);
+    else if (!ws._closeSeen) {
+      ws._closeSeen = true;
+      __sbWsOp("c", id, event.reason, event.code);
+    }
+    return;
+  }
+  ws._inbox.push(event);
+  __sbWsSchedule(ws);
+}
+
+// One event per turn, as workerd's receive loop does: a reply the handler sends reaches the
+// other end before this end's next message.
+function __sbWsSchedule(ws) {
+  if (ws._flushing || !ws._inbox.length || (!ws._accepted && ws._hib === null)) return;
+  ws._flushing = true;
+  Promise.resolve().then(() => {
+    ws._flushing = false;
+    if (ws._inbox.length && (ws._accepted || ws._hib !== null)) __sbWsDispatch(ws, ws._inbox.shift());
+    __sbWsSchedule(ws);
+  });
+}
+
+function __sbWsFlush(ws) {
+  while (ws._inbox.length && (ws._accepted || ws._hib !== null)) __sbWsDispatch(ws, ws._inbox.shift());
+}
+
+// Dispatches one event that arrived at ws: to its listeners, or to its Durable Object's
+// webSocketMessage / webSocketClose. A close is answered with a close (workerd replies to
+// a close automatically), and ends the socket.
+function __sbWsDispatch(ws, event) {
+  if (event.kind === 2) {
+    ws._closeSeen = true;
+    if (!ws._closeSent) {
+      ws._closeSent = true;
+      if (ws._peer !== null) __sbWsDeliver(ws._peer, { kind: 2, code: event.code, reason: event.reason, clean: event.clean });
+    }
+    ws._state = __SB_WS_CLOSED;
+    if (ws._hib !== null) return __sbWsHibernated(ws, "webSocketClose", [ws, event.code, event.reason, event.clean]);
+    return __sbWsFire(ws, { type: "close", code: event.code, reason: event.reason, wasClean: event.clean, target: ws });
+  }
+  if (ws._hib !== null) {
+    const auto = ws._hib.holder.auto;
+    if (auto !== null && event.kind === 0 && event.data === auto.request) {
+      ws.send(auto.response);
+      return;
+    }
+    return __sbWsHibernated(ws, "webSocketMessage", [ws, event.data]);
+  }
+  const data = event.kind === 1 && ws.binaryType !== "arraybuffer" ? new Blob([event.data]) : event.data;
+  __sbWsFire(ws, { type: "message", data, target: ws });
+}
+
+// A hibernatable socket's event runs the object's handler through its input gate.
+function __sbWsHibernated(ws, name, args) {
+  const inst = ws._hib.holder.inst;
+  if (inst == null || !__sbIsFn(inst[name])) return;
+  const run = () => {
+    if (name === "webSocketClose") return inst.webSocketClose(args[0], args[1], args[2], args[3]);
+    return inst.webSocketMessage(args[0], args[1]);
+  };
+  const done = (p) => {
+    if (p && __sbIsFn(p.then)) p.then(undefined, (error) => __sbLogUncaught("websocket", error));
+  };
+  try {
+    done(__sbDOGated() ? __sbDOEnter(inst.__sbGate, run) : run());
+  } catch (error) {
+    __sbLogUncaught("websocket", error);
+  }
+}
+
+// ctx.acceptWebSocket() and the rest of the hibernation API, added to a Durable Object's
+// state from 2026-10-30. `holder.inst` is the object once it exists.
+function __sbDOWebSocketState(state, holder) {
+  const sockets = [];
+  const live = () => {
+    for (let i = sockets.length - 1; i >= 0; i--) if (sockets[i]._state === __SB_WS_CLOSED) sockets.splice(i, 1);
+    return sockets;
+  };
+  state.acceptWebSocket = function (ws, tags) {
+    if (!(ws instanceof __SbWebSocket)) throw new TypeError("acceptWebSocket needs a WebSocket");
+    if (ws._accepted || ws._hib !== null || ws._host !== 0) throw new TypeError("This WebSocket was already accepted.");
+    const list = [];
+    if (tags != null) for (const t of tags) list.push(String(t));
+    if (list.length > 10) throw new TypeError("A WebSocket can have at most 10 tags.");
+    ws._hib = { holder, tags: list };
+    live().push(ws);
+    __sbWsSchedule(ws);
+  };
+  state.getWebSockets = function (tag) {
+    const out = [];
+    const all = live();
+    for (let i = 0; i < all.length; i++) if (tag === undefined || all[i]._hib.tags.indexOf(String(tag)) >= 0) out.push(all[i]);
+    return out;
+  };
+  state.getTags = function (ws) {
+    if (!(ws instanceof __SbWebSocket) || ws._hib === null) throw new TypeError("getTags: not a WebSocket accepted by this object");
+    return ws._hib.tags.slice();
+  };
+  state.setWebSocketAutoResponse = function (pair) {
+    if (pair != null && !(pair instanceof __SbWebSocketRequestResponsePair))
+      throw new TypeError("setWebSocketAutoResponse needs a WebSocketRequestResponsePair");
+    holder.auto = pair == null ? null : pair;
+  };
+  state.getWebSocketAutoResponse = function () {
+    return holder.auto;
+  };
+  state.getWebSocketAutoResponseTimestamp = function () {
+    return null;
+  };
+  state.setHibernatableWebSocketEventTimeout = function () {};
+  state.getHibernatableWebSocketEventTimeout = function () {
+    return null;
+  };
+}
+
+function __sbWsEnabled() {
+  return globalThis.WebSocketPair === __SbWebSocketPair;
+}
+function __sbHasWebSocket(r) {
+  return r != null && r._webSocket != null && __sbWsEnabled();
+}
+
+// The client end of a 101 response becomes a host socket: marked x-sb-websocket for the
+// host (which upgrades the connection), with what the app already sent going out after it.
+function __sbWsHostResponse(r) {
+  const ws = r._webSocket;
+  if (!(ws instanceof __SbWebSocket) || ws._host !== 0 || ws._accepted || ws._hib !== null) {
+    return __sbErrorResponse(new TypeError("A 101 response needs the unaccepted client end of a WebSocketPair."), false);
+  }
+  const id = Number(__sbWsOp("o", 0, "", 0));
+  if (!(id > 0)) return new Response("WebSockets are not supported by this host yet", { status: 501 });
+  ws._host = id;
+  r.headers._immutable = false;
+  r.headers.set("x-sb-websocket", String(id));
+  const held = ws._inbox;
+  ws._inbox = [];
+  for (let i = 0; i < held.length; i++) __sbWsDeliver(ws, held[i]);
+  __sbWsPump(ws);
+  return r;
+}
+
+// Takes what the host received on ws's socket and dispatches it to the app's end, then
+// waits (a parked timer the host fires) for more.
+function __sbWsPump(ws) {
+  const id = ws._host;
+  for (;;) {
+    const head = __sbWsOp("p", id, "", 0);
+    if (head === "") {
+      const timer = setTimeout(() => __sbWsPump(ws), 2147483647);
+      __sbWsOp("w", id, "", timer);
+      return;
+    }
+    const parts = head.split(" ");
+    const kind = Number(parts[0]);
+    const length = Number(parts[1]);
+    const bytes = new Uint8Array(length);
+    __sbWsOp("i", id, bytes, 0);
+    let event;
+    if (kind === 1) event = { kind: 1, data: bytes.buffer };
+    else if (kind === 0 || kind === 2) {
+      let text = length > 0 ? __sbFromUtf8Native(bytes) : "";
+      if (text === "" && length > 0) text = new TextDecoder().decode(bytes);
+      event = kind === 0 ? { kind: 0, data: text } : { kind: 2, code: Number(parts[2]), reason: text, clean: true };
+    } else event = { kind: 2, code: 1006, reason: "WebSocket disconnected without sending Close frame.", clean: false };
+    if (event.kind === 2) ws._closeSeen = true;
+    const peer = ws._peer;
+    if (peer !== null) {
+      peer._inbox.push(event);
+      // Dispatched now, so the acknowledgement below means the handler has run.
+      if (!peer._flushing) __sbWsFlush(peer);
+    }
+    __sbWsOp("k", id, "", length);
+    if (event.kind === 2) {
+      __sbWsOp("r", id, "", 0);
+      return;
+    }
+  }
+}
+
+function __sbInstallWebSockets() {
+  if (globalThis.__sbCompat < "2026-10-30") return;
+  globalThis.WebSocketPair = __SbWebSocketPair;
+  globalThis.WebSocket = __SbWebSocket;
+  globalThis.WebSocketRequestResponsePair = __SbWebSocketRequestResponsePair;
+}
+
+async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
+    if (top && __sbHasWebSocket(r)) r = __sbWsHostResponse(r);
     if (__sbHasStreamBody(r)) {
       if (__sbStreamingSupported()) __sbStreamResponse(r);
       else r.body = await __sbCollectBody(__sbRawBody(r));
@@ -8141,7 +8726,9 @@ globalThis.__sbEntry = function (handlers, request) {
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
-    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall, false, true);
+    // A WebSocket handshake answer (from 2026-10-30): its client end becomes the host socket.
+    if (__sbHasWebSocket(__res)) return __sbWsHostResponse(__res);
     return __sbTagCpu(__res, __t0);
   }
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });
@@ -8226,37 +8813,64 @@ globalThis.__sbEntry = function (handlers, request) {
  * timer in an embedded binary that has no broker to be delivered from.
  */
 async function __sbRunQueueBatch(handlers, body, ctx) {
+  const strict = __sbQueuesStrict();
+  const binding = String(body.queue || "");
+  const settings = __sbQueueSettings(binding);
   const acked = [];
   const retried = [];
+  // id -> seconds, from retry({ delaySeconds }) (2026-10-31)
+  const delays = {};
   let threw = false;
   const raw = body.messages || [];
   const messages = [];
-  for (let i = 0; i < raw.length; i++) {
-    const m = raw[i];
-    const msg = {
-      id: m.id,
-      timestamp: m.timestamp,
-      attempts: m.attempts || 1,
-      body: __sbTryParse(m.body),
-      ack() {
-        if (acked.indexOf(m.id) === -1) acked.push(m.id);
+  let batch;
+  if (strict) {
+    // The first of ack() and retry() on a message wins; ackAll() and retryAll() decide the
+    // messages nothing has decided yet.
+    const decided = {};
+    const ack = (id) => {
+      if (decided[id] !== true) {
+        decided[id] = true;
+        acked.push(id);
+      }
+    };
+    const retry = (id, options) => {
+      if (decided[id] !== true) {
+        decided[id] = true;
+        retried.push(id);
+        if (options && options.delaySeconds != null) delays[id] = __sbQueueDelay(options.delaySeconds);
+      }
+    };
+    for (let i = 0; i < raw.length; i++) messages.push(new __SbQueueMessage(raw[i], ack, retry));
+    batch = new __SbQueueBatch(settings.queue, messages, body.metadata, ack, retry);
+  } else {
+    for (let i = 0; i < raw.length; i++) {
+      const m = raw[i];
+      const msg = {
+        id: m.id,
+        timestamp: m.timestamp,
+        attempts: m.attempts || 1,
+        body: __sbQueueDecode(m.body),
+        ack() {
+          if (acked.indexOf(m.id) === -1) acked.push(m.id);
+        },
+        retry() {
+          if (retried.indexOf(m.id) === -1) retried.push(m.id);
+        },
+      };
+      messages.push(msg);
+    }
+    batch = {
+      queue: settings.queue,
+      messages,
+      ackAll() {
+        for (let i = 0; i < messages.length; i++) messages[i].ack();
       },
-      retry() {
-        if (retried.indexOf(m.id) === -1) retried.push(m.id);
+      retryAll() {
+        for (let i = 0; i < messages.length; i++) messages[i].retry();
       },
     };
-    messages.push(msg);
   }
-  const batch = {
-    queue: body.queue || "",
-    messages,
-    ackAll() {
-      for (let i = 0; i < messages.length; i++) messages[i].ack();
-    },
-    retryAll() {
-      for (let i = 0; i < messages.length; i++) messages[i].retry();
-    },
-  };
   try {
     const __qres = globalThis.__sbCompat >= "2026-09-28"
       ? handlers.queue(batch, globalThis.env, ctx)
@@ -8274,12 +8888,65 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
   // A message neither acked nor retried is acked when the handler returns, and retried
   // when it throws, as on Workers. A throw used to ack the whole batch on the embedded
   // transport (standalone, sproutd), so a failing consumer lost its messages.
-  for (let i = 0; i < messages.length; i++) {
-    if (acked.indexOf(messages[i].id) === -1 && retried.indexOf(messages[i].id) === -1)
-      (threw ? retried : acked).push(messages[i].id);
+  for (let i = 0; i < raw.length; i++) {
+    if (acked.indexOf(raw[i].id) === -1 && retried.indexOf(raw[i].id) === -1)
+      (threw ? retried : acked).push(raw[i].id);
+  }
+  const out = { ack: acked, retry: retried };
+  // Retry delays and what happens past the last retry. Sent only where they differ from
+  // what a store does by itself (5 s, 5 attempts, then marked dead), so earlier dates
+  // without settings answer as before. A store that predates these fields (an older
+  // broker) ignores them and retries the messages listed in `retry`.
+  if (strict || settings.maxRetries !== undefined || settings.retryDelay !== undefined || settings.deadLetterQueue !== undefined) {
+    const maxRetries = settings.maxRetries !== undefined ? settings.maxRetries : strict ? 3 : 4;
+    const retryDelay = settings.retryDelay !== undefined ? settings.retryDelay : strict ? 0 : 5;
+    const attempts = {};
+    for (let i = 0; i < raw.length; i++) attempts[raw[i].id] = Number(raw[i].attempts) || 1;
+    out.delays = {};
+    out.dead = [];
+    for (let i = 0; i < retried.length; i++) {
+      const id = retried[i];
+      if (attempts[id] > maxRetries) out.dead.push(id);
+      else out.delays[id] = delays[id] !== undefined ? delays[id] : retryDelay;
+    }
+    if (out.dead.length && settings.deadLetterQueue !== undefined) out.deadLetter = __sbQueuePart(settings.deadLetterQueue);
   }
-  return { ack: acked, retry: retried };
+  return out;
+}
+
+// A delivered message and batch from 2026-10-31: their data are own properties, as in
+// workerd, and ack/retry live on the prototype, out of Object.keys().
+function __SbQueueMessage(m, ack, retry) {
+  this.id = String(m.id);
+  this.timestamp = new Date(Number(m.timestamp) || Date.now());
+  let decoded;
+  try {
+    decoded = __sbQueueDecode(m.body);
+  } catch {
+    decoded = m.body;
+  }
+  this.body = decoded;
+  this.attempts = Number(m.attempts) || 1;
+  Object.defineProperty(this, "__sbDecide", { value: { ack, retry }, enumerable: false });
 }
+__SbQueueMessage.prototype.ack = function () {
+  this.__sbDecide.ack(this.id);
+};
+__SbQueueMessage.prototype.retry = function (options) {
+  this.__sbDecide.retry(this.id, options);
+};
+function __SbQueueBatch(queue, messages, metadata, ack, retry) {
+  this.queue = queue;
+  this.messages = messages;
+  this.metadata = { metrics: __sbQueueMetrics(metadata && metadata.metrics) };
+  Object.defineProperty(this, "__sbDecide", { value: { ack, retry }, enumerable: false });
+}
+__SbQueueBatch.prototype.ackAll = function () {
+  for (let i = 0; i < this.messages.length; i++) this.__sbDecide.ack(this.messages[i].id);
+};
+__SbQueueBatch.prototype.retryAll = function (options) {
+  for (let i = 0; i < this.messages.length; i++) this.__sbDecide.retry(this.messages[i].id, options);
+};
 
 function __sbReadJson(request) {
   try {