@sproutboat/runtime 0.35.0 → 0.37.1

package/src/native-fetch-prelude.js

@@ -3104,16 +3104,14 @@ function __sbCpuMs() {
   return ms;
 }
 
-// The `x-sb-cpu-ms` value for the CPU time since `t0`, as three decimals, floored at zero: one
-// clock read and one format call in C, where it was a read, a format, a parse and a toFixed.
-// oxlint-disable-next-line no-unused-vars -- `t0` is read inside the RawC block below, not by JS.
-function __sbCpuStamp(t0) {
+// The `x-sb-cpu-ms` value for a CPU time in ms, as three decimals, floored at zero: one format call
+// in C, where it was a format, a parse and a toFixed.
+// oxlint-disable-next-line no-unused-vars -- `cpu` is read inside the RawC block below, not by JS.
+function __sbCpuStamp(cpu) {
   let res = "0.000";
   // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
   Porffor.c`
-    struct timespec __ts;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &__ts);
-    double __d = ((double)__ts.tv_sec * 1000.0 + (double)__ts.tv_nsec / 1000000.0) - (t0.type == 1 ? (double)t0.val : 0.0);
+    double __d = cpu.type == 1 ? (double)cpu.val : 0.0;
     if (!(__d >= 0)) __d = 0;
     char __b[32];
     int __n = snprintf(__b, sizeof(__b), "%.3f", __d);
@@ -3122,6 +3120,33 @@ function __sbCpuStamp(t0) {
   return res;
 }
 
+// Per-request CPU (toolchain async-context.ts): a request is a small id whose thread CPU time is
+// summed over the slices in which it ran, however requests interleave. 0 when no slot is free.
+function __sbCpuBegin() {
+  let id = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    id = (f64)porf_cpu_begin();
+  `;
+  return id;
+}
+// oxlint-disable-next-line no-unused-vars -- `cell` is read inside the RawC block below, not by JS.
+function __sbCpuTake(cell) {
+  let ms = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    ms = porf_cpu_read_ms((u32)cell.val);
+  `;
+  return ms;
+}
+// oxlint-disable-next-line no-unused-vars -- `cell` is read inside the RawC block below, not by JS.
+function __sbCpuEnd(cell) {
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    porf_cpu_end((u32)cell.val);
+  `;
+}
+
 // #28 — stamp `x-sb-cpu-ms` onto a handler Response. Porffor alpha-10's
 // native-fetch serializer only reads headers from the plain object passed to
 // `new Response(body, { headers })` — a later `.set()` or a `Headers` instance
@@ -3129,7 +3154,7 @@ function __sbCpuStamp(t0) {
 // with one extra header. Safe only for a string body (the norm under
 // http-sync-v0) with no Set-Cookie to comma-fold; anything else is returned
 // untouched and the edge simply omits cpuMs for that request.
-function __sbTagCpu(res, t0) {
+function __sbTagCpu(res, cpu) {
   try {
     // A string body and no Set-Cookie, as before. The native writer reads Headers' flat `_entries`,
     // so the stamp is appended to the handler's own Response instead of building a second one (a
@@ -3137,7 +3162,7 @@ function __sbTagCpu(res, t0) {
     // the handler set itself is replaced by the measured one, as before.
     const headers = res && res.headers;
     if (headers && __sbIsStr(__sbRawBody(res)) && !headers.has("set-cookie")) {
-      const stamp = __sbCpuStamp(t0);
+      const stamp = __sbCpuStamp(cpu);
       const entries = headers._entries;
       let set = false;
       for (let i = 0; i < entries.length; i += 2) {
@@ -3617,9 +3642,17 @@ __sbDefineURLAccessor("password", function () {
 // fallback — a silent downgrade to a weak source is worse than throwing.
 if (globalThis.crypto == null) globalThis.crypto = {};
 if (globalThis.crypto.getRandomValues == null) {
+  // Every byte of the view, as WebCrypto fills it: a Uint32Array gets 4 random bytes per element.
+  // Only integer views are accepted (a Float32Array or a DataView throws TypeMismatchError), and one
+  // call may ask for at most 65536 bytes.
   globalThis.crypto.getRandomValues = function (view) {
-    const n = view.length >>> 0;
-    // WebCrypto caps a single call at 65536 bytes.
+    const integer = ArrayBuffer.isView(view) && !(view instanceof DataView) && !(view instanceof Float32Array) && !(view instanceof Float64Array);
+    if (!integer) {
+      const e = new Error("The data argument must be an integer-type TypedArray");
+      e.name = "TypeMismatchError";
+      throw e;
+    }
+    const n = view.byteLength >>> 0;
     if (n > 65536) {
       // WebCrypto's error for an oversized request (a DOMException named QuotaExceededError).
       const e = new Error("crypto.getRandomValues: byte length exceeds 65536");
@@ -3627,11 +3660,10 @@ if (globalThis.crypto.getRandomValues == null) {
       throw e;
     }
     if (n === 0) return view;
-    // One CSPRNG byte per element. Correct for Uint8Array (and randomUUID); a
-    // wider view gets its low byte filled, matching the previous polyfill's shape.
-    const bytes = __sbRandomBytes(String(n));
-    if (bytes.length !== n) throw new Error("crypto.getRandomValues: OS entropy source unavailable");
-    for (let i = 0; i < n; i++) view[i] = bytes.charCodeAt(i) & 0xff;
+    const random = __sbRandomBytes(String(n));
+    if (random.length !== n) throw new Error("crypto.getRandomValues: OS entropy source unavailable");
+    const out = new Uint8Array(view.buffer, view.byteOffset, n);
+    for (let i = 0; i < n; i++) out[i] = random.charCodeAt(i) & 0xff;
     return view;
   };
 }
@@ -3713,6 +3745,40 @@ if (globalThis.crypto.getRandomValues == null) {
   };
 }
 
+// DOMException. Porffor's own global is a stub that reports typeof "function" but cannot be
+// constructed (`new DOMException("m", "AbortError")` throws "not a constructor"), so the runtime
+// installs a real one: legacy codes, the named constants, the options form with `cause`, and
+// instanceof Error, as in workerd. AbortSignal reasons, the stream polyfill and WebCrypto errors
+// use it, so a library can test `error instanceof DOMException` and `error.name`.
+const __sbDomCodes = {
+  IndexSizeError: 1, HierarchyRequestError: 3, WrongDocumentError: 4, InvalidCharacterError: 5,
+  NoModificationAllowedError: 7, NotFoundError: 8, NotSupportedError: 9, InUseAttributeError: 10,
+  InvalidStateError: 11, SyntaxError: 12, InvalidModificationError: 13, NamespaceError: 14,
+  InvalidAccessError: 15, TypeMismatchError: 17, SecurityError: 18, NetworkError: 19,
+  AbortError: 20, URLMismatchError: 21, QuotaExceededError: 22, TimeoutError: 23,
+  InvalidNodeTypeError: 24, DataCloneError: 25,
+};
+/* oxlint-disable anti-slop/no-runtime-typeof -- the second argument is a name or an options bag, as in WebIDL */
+class __SbDOMException extends Error {
+  constructor(message = "", options = "Error") {
+    super(message === undefined ? "" : String(message));
+    let name = "Error";
+    if (options !== null && typeof options === "object") {
+      name = options.name === undefined ? "Error" : String(options.name);
+      if ("cause" in options) this.cause = options.cause;
+    } else if (options !== undefined) name = String(options);
+    this.name = name;
+    const code = __sbDomCodes[name];
+    this.code = code === undefined ? 0 : code;
+  }
+}
+for (const key of Object.keys(__sbDomCodes)) {
+  const constant = key.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase().replace(/_ERROR$/, "_ERR");
+  __SbDOMException[constant] = __sbDomCodes[key];
+}
+/* oxlint-enable anti-slop/no-runtime-typeof */
+globalThis.DOMException = __SbDOMException;
+
 /* oxlint-disable anti-slop/no-runtime-typeof -- these Web API polyfills branch on JavaScript types
    exactly where their specs do (listener: function or { handleEvent }; structured clone: by value type). */
 // Event, CustomEvent, EventTarget, AbortSignal and AbortController, as workerd has
@@ -3720,11 +3786,7 @@ if (globalThis.crypto.getRandomValues == null) {
 // conformance suite; libraries use AbortController for fetch timeouts and EventTarget
 // for their own events.
 if (typeof globalThis.EventTarget !== "function") {
-  const namedError = (name, message) => {
-    const e = new Error(message);
-    e.name = name;
-    return e;
-  };
+  const namedError = (name, message) => new globalThis.DOMException(message, name);
   class Event {
     constructor(type, init) {
       if (arguments.length === 0) throw new TypeError("Event requires a type");
@@ -4243,9 +4305,7 @@ function __sbHexOrBytes(value) {
 
 // Errors as WebCrypto names them (DOMException names; plain Errors here).
 function __sbCryptoError(name, message) {
-  const e = new Error(message);
-  e.name = name;
-  return e;
+  return new globalThis.DOMException(message, name);
 }
 // An HMAC key as importKey and generateKey return it. MD5 is digest-only, as in workerd.
 function __sbHmacKey(bytes, bits, extractable, usages) {
@@ -5331,6 +5391,7 @@ function __sbRpcDirect(op, extra) {
 function __sbD1Rpc(op, extra, strict) {
   if (!strict) return __sbRpcDirect(op, extra);
   extra.strict = true;
+  if (__sbD1Parity()) extra.parity = true;
   try {
     return __sbRpcDirect(op, extra);
   } catch (err) {
@@ -5395,10 +5456,104 @@ function __sbD1IsTransaction(text) {
     word === "begin" || word === "commit" || word === "end" || word === "rollback" || word === "savepoint" || word === "release"
   );
 }
+// From 2026-11-03: workerd's D1 authorizer lets a PRAGMA run only if it is one of these (the name as
+// written: PRAGMA TABLE_INFO is refused, as is any schema but main). Any other reads "not authorized".
+// Checked in the shim, so every transport answers alike. A query or batch statement is only looked at
+// when it starts with P (after spaces and comments); an exec line is scanned statement by statement.
+function __sbD1Parity() {
+  return __sbCompatDate() >= "2026-11-03";
+}
+var __sbD1PragmaAllowed =
+  " table_list table_info table_xinfo index_list index_info index_xinfo foreign_keys foreign_key_list foreign_key_check quick_check optimize defer_foreign_keys case_sensitive_like recursive_triggers data_version legacy_alter_table reverse_unordered_selects ignore_check_constraints ";
+var __sbD1NotAuthorized = "D1_ERROR: not authorized: SQLITE_AUTH";
+function __sbD1IsIdent(c) {
+  return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || c === 95 || (c >= 97 && c <= 122) || c > 127;
+}
+// Index of the first character at or after i that is not whitespace, a comment, or (when
+// semicolons) a semicolon.
+function __sbD1SkipBlank(s, i, semicolons) {
+  for (;;) {
+    const c = s.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || (semicolons && c === 59)) i++;
+    else if (c === 45 && s.charCodeAt(i + 1) === 45) {
+      while (i < s.length && s.charCodeAt(i) !== 10) i++;
+    } else if (c === 47 && s.charCodeAt(i + 1) === 42) {
+      const end = s.indexOf("*/", i + 2);
+      i = end < 0 ? s.length : end + 2;
+    } else return i;
+  }
+}
+// An identifier at i (plain, or quoted with " ` or [ ]): its text and where it ends.
+function __sbD1Name(s, i) {
+  const q = s.charCodeAt(i);
+  if (q === 34 || q === 96 || q === 91) {
+    const end = s.indexOf(q === 91 ? "]" : String.fromCharCode(q), i + 1);
+    if (end < 0) return { text: s.slice(i + 1), end: s.length };
+    return { text: s.slice(i + 1, end), end: end + 1 };
+  }
+  let end = i;
+  while (end < s.length && __sbD1IsIdent(s.charCodeAt(end))) end++;
+  return { text: s.slice(i, end), end };
+}
+// The statement at i (already past blanks): 0 when it is not a PRAGMA or one D1 allows, 1 when D1 refuses
+// it, 2 when it sets foreign_keys (which D1 never lets a call switch off: the pragma is a no-op inside
+// the transaction every D1 call runs in, so the caller puts it back).
+function __sbD1PragmaKind(s, i) {
+  if ((s.charCodeAt(i) | 32) !== 112 || s.slice(i, i + 6).toLowerCase() !== "pragma" || __sbD1IsIdent(s.charCodeAt(i + 6))) return 0;
+  let at = __sbD1SkipBlank(s, i + 6, false);
+  let name = __sbD1Name(s, at);
+  at = __sbD1SkipBlank(s, name.end, false);
+  if (s.charCodeAt(at) === 46) {
+    // schema.name: SQLite itself answers for a schema that does not exist
+    const schema = name.text.toLowerCase();
+    if (schema !== "main") return schema === "temp" ? 1 : 0;
+    name = __sbD1Name(s, __sbD1SkipBlank(s, at + 1, false));
+    at = __sbD1SkipBlank(s, name.end, false);
+  }
+  if (__sbD1PragmaAllowed.indexOf(" " + name.text + " ") < 0) return 1;
+  const next = s.charCodeAt(at);
+  return name.text === "foreign_keys" && (next === 61 || next === 40) ? 2 : 0;
+}
+// A query or batch statement (its first character is P, - ; or /): only its first statement is looked
+// at. Returns 2 for a foreign_keys assignment.
+function __sbD1CheckPragma(text) {
+  const at = __sbD1SkipBlank(text, 0, true);
+  if (at >= text.length) throw __sbD1Fail("D1_ERROR: SQL code did not contain a statement.");
+  const kind = __sbD1PragmaKind(text, at);
+  if (kind === 1) throw __sbD1Fail(__sbD1NotAuthorized);
+  return kind;
+}
+// An exec line can hold several statements: look at the start of each. A ';' inside a quoted name or
+// string or a comment does not end one.
+function __sbD1LinePragmaDenied(line) {
+  if (line.toLowerCase().indexOf("pragma") < 0) return false;
+  let i = __sbD1SkipBlank(line, 0, true);
+  while (i < line.length) {
+    if (__sbD1PragmaKind(line, i) === 1) return true;
+    let c = line.charCodeAt(i);
+    while (i < line.length && c !== 59) {
+      if (c === 39 || c === 34 || c === 96 || c === 91) {
+        const end = line.indexOf(c === 91 ? "]" : String.fromCharCode(c), i + 1);
+        i = end < 0 ? line.length : end + 1;
+      } else if ((c === 45 && line.charCodeAt(i + 1) === 45) || (c === 47 && line.charCodeAt(i + 1) === 42)) i = __sbD1SkipBlank(line, i, false);
+      else i++;
+      c = line.charCodeAt(i);
+    }
+    i = __sbD1SkipBlank(line, i, true);
+  }
+  return false;
+}
 function __sbD1Check(sql) {
   const text = String(sql).trim();
   if (!text) throw __sbD1Fail("D1_ERROR: No SQL statements detected.");
   if (__sbD1IsTransaction(text)) throw __sbD1Fail(__sbD1NoTransactions);
+  const first = text.charCodeAt(0);
+  let kind = 0;
+  if (((first | 32) === 112 || first === 45 || first === 47 || first === 59) && __sbD1Parity()) kind = __sbD1CheckPragma(text);
+  // more statements behind the first run too (2026-11-03), each one through the allow-list
+  const semi = text.indexOf(";");
+  if (semi >= 0 && semi < text.length - 1 && __sbD1Parity() && __sbD1LinePragmaDenied(text)) throw __sbD1Fail(__sbD1NotAuthorized);
+  return kind;
 }
 function __sbD1Meta(meta, started) {
   const changes = Number(meta.changes) || 0;
@@ -5450,10 +5605,11 @@ function __sbD1Direct(name, sql, params) {
 // when the caller will hand it out (all() and run()): raw() and first() drop it, and building it
 // reads the clock twice.
 function __sbD1Query(dbName, sql, params, strict, wantMeta) {
-  if (strict) __sbD1Check(sql);
+  const foreignKeys = strict ? __sbD1Check(sql) : 0;
   const started = !strict || wantMeta ? Date.now() : 0;
   const r = strict && __sbD1QueryDirect ? __sbD1Direct(dbName, sql, params) : __sbD1Rpc("d1.query", { db: dbName, sql, params }, strict);
   if (!strict) return { results: r.results || [], success: true, meta: r.meta || {} };
+  if (foreignKeys === 2) __sbD1Rpc("d1.query", { db: dbName, sql: "PRAGMA foreign_keys = ON", params: [] }, true);
   const table = __sbD1Table(r);
   return { columns: table.columns, rows: table.rows, meta: wantMeta ? __sbD1Meta(r.meta || {}, started) : null };
 }
@@ -5550,8 +5706,16 @@ function __sbMakeD1(dbName) {
     const all = String(sql).trim().split("\n");
     const lines = [];
     for (let i = 0; i < all.length; i++) if (all[i].trim()) lines.push(all[i]);
-    if (!lines.length) throw __sbD1Fail("D1_ERROR: No SQL statements detected.");
-    __sbD1Rpc("d1.exec", { db: dbName, sql: lines.join("\n"), lines }, true);
+    const parity = __sbD1Parity();
+    if (!lines.length)
+      throw __sbD1Fail(parity ? "D1_EXEC_ERROR: Error in line 1: : No SQL statements detected." : "D1_ERROR: No SQL statements detected.");
+    if (parity)
+      for (let i = 0; i < lines.length; i++) {
+        const head = "D1_EXEC_ERROR: Error in line " + (i + 1) + ": " + lines[i] + ": ";
+        if (__sbD1SkipBlank(lines[i], 0, true) >= lines[i].length) throw __sbD1Fail(head + "SQL code did not contain a statement.");
+        if (__sbD1LinePragmaDenied(lines[i])) throw __sbD1Fail(head + "not authorized: SQLITE_AUTH");
+      }
+    __sbD1Rpc("d1.exec", parity ? { db: dbName, sql: lines.join("\n"), lines, parity: true } : { db: dbName, sql: lines.join("\n"), lines }, true);
     return { count: lines.length, duration: Date.now() - started };
   }
   const db = {
@@ -6018,6 +6182,13 @@ function __sbAssetResponse(path, r) {
 function __sbQueuesStrict() {
   return __sbCompatDate() >= "2026-10-31";
 }
+// From 2026-11-05: the v8 codec keeps shared and circular references, array holes and invalid
+// dates; arguments are checked as workerd checks them; delaySeconds is limited to a day; a
+// delivery that never came back counts as a retry (to the dead letter queue after max_retries);
+// a consumer that runs past the lease keeps its messages.
+function __sbQueuesFixed() {
+  return __sbCompatDate() >= "2026-11-05";
+}
 
 // binding -> { binding, queue, maxBatchSize?, maxBatchTimeout?, maxRetries?, retryDelay?, deadLetterQueue? }
 var __sbQueueConf = {};
@@ -6056,7 +6227,7 @@ function __sbQueueTypeName(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 type = contentType === undefined ? "json" : contentType;
   let payload;
   let size;
   if (type === "json") {
@@ -6076,13 +6247,18 @@ function __sbQueueEncode(body, contentType) {
     payload = body;
     size = new TextEncoder().encode(body).length;
   } else if (type === "bytes") {
-    const bytes = __sbQueueBytesOf(body);
+    const bytes = __sbQueuesFixed() && !ArrayBuffer.isView(body) ? null : __sbQueueBytesOf(body);
     if (bytes === null)
-      throw new TypeError('Content Type "bytes" requires a value of type ArrayBuffer, but received: ' + __sbQueueTypeName(body));
+      throw new TypeError(
+        'Content Type "bytes" requires a value of type ' + (__sbQueuesFixed() ? "ArrayBufferView" : "ArrayBuffer") + ", but received: " + __sbQueueTypeName(body),
+      );
     payload = __sbDOHex(bytes);
     size = bytes.length;
   } else if (type === "v8") {
-    payload = JSON.stringify(__sbDOPack(body, []));
+    if (__sbQueuesFixed()) {
+      payload = JSON.stringify(__sbQV8Pack(body, []));
+      type = "v8r";
+    } else payload = JSON.stringify(__sbDOPack(body, []));
     size = new TextEncoder().encode(payload).length;
   } else throw new TypeError("Unsupported queue message content type: " + type);
   if (size > __sbQueueMaxMessage)
@@ -6101,10 +6277,124 @@ function __sbQueueDecode(raw) {
     if (type === "json") return JSON.parse(payload);
     if (type === "bytes") return __sbDOUnhex(payload).buffer;
     if (type === "v8") return __sbDOUnpack(JSON.parse(payload));
+    if (type === "v8r") return __sbQV8Unpack(JSON.parse(payload), []);
   }
   return __sbTryParse(raw);
 }
 
+/* oxlint-disable anti-slop/no-runtime-typeof -- structured clone branches on the value's type, as the HTML spec's StructuredSerialize does. */
+// The v8 content type from 2026-11-05: __sbDOPack's JSON, plus references. Every object is
+// numbered when first met (before its contents); meeting it again is ["@", n], which makes
+// shared and circular values come back shared and circular. An array is ["A", length, ...] with
+// ["H"] for a hole; an invalid Date is ["D", "NaN"]. Typed arrays other than Uint8Array and
+// DataView stay unsupported (see __sbDOView).
+function __sbQV8Pack(v, objs) {
+  if (v === null || v === true || v === false || __sbIsStr(v)) return v;
+  const t = typeof v;
+  if (t === "number") {
+    if (v === 0 && 1 / v < 0) return ["N", "-0"];
+    return Number.isFinite(v) ? v : ["N", String(v)];
+  }
+  if (t === "bigint") return ["B", String(v)];
+  if (t === "undefined") return ["U"];
+  if (t !== "object") throw __sbDOCloneError(t === "symbol" ? v.toString() : v);
+  const seen = objs.indexOf(v);
+  if (seen !== -1) return ["@", seen];
+  objs.push(v);
+  if (v instanceof Date) {
+    const time = v.getTime();
+    return ["D", time === time ? time : "NaN"];
+  }
+  if (v instanceof Map) {
+    const out = ["M"];
+    v.forEach((x, k) => {
+      out.push(__sbQV8Pack(k, objs), __sbQV8Pack(x, objs));
+    });
+    return out;
+  }
+  if (v instanceof Set) {
+    const out = ["S"];
+    v.forEach((x) => {
+      out.push(__sbQV8Pack(x, objs));
+    });
+    return out;
+  }
+  if (v instanceof ArrayBuffer) return ["AB", __sbDOHex(new Uint8Array(v))];
+  if (ArrayBuffer.isView(v)) {
+    const name = Object.prototype.toString.call(v).slice(8, -1);
+    if (name !== "Uint8Array" && name !== "DataView") {
+      const error = new Error(name + " is not supported in a v8 queue message here yet; send a Uint8Array of its bytes.");
+      error.name = "DataCloneError";
+      throw error;
+    }
+    return ["V", name, __sbDOHex(new Uint8Array(v.buffer, v.byteOffset, v.byteLength))];
+  }
+  if (v instanceof RegExp) return ["R", v.source, v.flags];
+  if (Array.isArray(v)) {
+    const out = ["A", v.length];
+    for (let i = 0; i < v.length; i++) out.push(i in v ? __sbQV8Pack(v[i], objs) : ["H"]);
+    return out;
+  }
+  if (v instanceof Error) return ["E", String(v.name), String(v.message)];
+  const out = ["O"];
+  const keys = Object.keys(v);
+  for (let i = 0; i < keys.length; i++) out.push(keys[i], __sbQV8Pack(v[keys[i]], objs));
+  return out;
+}
+/* oxlint-enable anti-slop/no-runtime-typeof */
+
+function __sbQV8Unpack(p, objs) {
+  if (!Array.isArray(p)) return p;
+  const tag = p[0];
+  if (tag === "@") return objs[p[1]];
+  if (tag === "U") return undefined;
+  if (tag === "N") return p[1] === "-0" ? -0 : Number(p[1]);
+  if (tag === "B") return BigInt(p[1]);
+  let out;
+  if (tag === "D") {
+    out = new Date(p[1] === "NaN" ? NaN : p[1]);
+    objs.push(out);
+  } else if (tag === "AB") {
+    out = __sbDOUnhex(p[1]).buffer;
+    objs.push(out);
+  } else if (tag === "V") {
+    out = __sbDOView(p[1], __sbDOUnhex(p[2]));
+    objs.push(out);
+  } else if (tag === "R") {
+    out = new RegExp(p[1], p[2]);
+    objs.push(out);
+  } else if (tag === "E") {
+    out = p[1] === "TypeError" ? new TypeError(p[2]) : p[1] === "RangeError" ? new RangeError(p[2]) : new Error(p[2]);
+    out.name = p[1];
+    objs.push(out);
+  } else if (tag === "M") {
+    out = new Map();
+    objs.push(out);
+    for (let i = 1; i + 1 < p.length; i += 2) {
+      const k = __sbQV8Unpack(p[i], objs);
+      out.set(k, __sbQV8Unpack(p[i + 1], objs));
+    }
+  } else if (tag === "S") {
+    out = new Set();
+    objs.push(out);
+    for (let i = 1; i < p.length; i++) out.add(__sbQV8Unpack(p[i], objs));
+  } else if (tag === "A") {
+    out = [];
+    objs.push(out);
+    out.length = p[1];
+    for (let i = 2; i < p.length; i++) {
+      const e = p[i];
+      if (Array.isArray(e) && e[0] === "H") continue;
+      out[i - 2] = __sbQV8Unpack(e, objs);
+    }
+  } else {
+    out = {};
+    objs.push(out);
+    for (let i = 1; i + 1 < p.length; i += 2) out[p[i]] = __sbQV8Unpack(p[i + 1], objs);
+  }
+  return out;
+}
+
 function __sbQueueMetrics(metrics) {
   const m = metrics || {};
   const oldest = Number(m.oldestMessageTimestamp) || 0;
@@ -6119,12 +6409,30 @@ function __sbQueueMetrics(metrics) {
 function __sbQueueDelay(value) {
   return value == null ? 0 : Math.max(0, Number(value) || 0);
 }
+// From 2026-11-05 a delay outside 0 to 86400 s (a day) is refused, not clamped or kept.
+function __sbQueueCheckDelay(value) {
+  if (!__sbQueuesFixed() || value == null) return;
+  const n = Number(value);
+  if (n < 0 || n > 86400) throw new Error("Queue send failed: delaySeconds must be between 0 and 86400, got " + String(value));
+}
+// workerd's check that an options argument is a dictionary (null and undefined are fine).
+function __sbQueueCheckOptions(options, name, position, type) {
+  if (!__sbQueuesFixed() || options == null) return;
+  if (__sbQueueTypeName(options) !== "object")
+    throw new TypeError("Failed to execute '" + name + "' on 'WorkerQueue': parameter " + position + " is not of type '" + type + "'.");
+}
 
 function __sbMakeQueue(binding) {
   return {
-    send(body, options) {
+    send(...args) {
       try {
+        const body = args[0];
+        const options = args[1];
+        if (args.length === 0 && __sbQueuesFixed())
+          throw new TypeError("Failed to execute 'send' on 'WorkerQueue': parameter 1 is not of type 'JsValue'.");
+        __sbQueueCheckOptions(options, "send", 2, "SendOptions");
         const o = options || {};
+        __sbQueueCheckDelay(o.delaySeconds);
         const encoded = __sbQueueEncode(body, o.contentType);
         const reply = __sbRpc("queue.send", {
           queue: binding,
@@ -6141,11 +6449,16 @@ function __sbMakeQueue(binding) {
       try {
         if (messages == null || !__sbIsFn(messages[Symbol.iterator]))
           throw new TypeError("Failed to execute 'sendBatch' on 'WorkerQueue': parameter 1 is not of type 'Sequence'.");
+        __sbQueueCheckOptions(options, "sendBatch", 2, "SendBatchOptions");
+        __sbQueueCheckDelay(options && options.delaySeconds);
         const batchDelay = __sbQueueDelay(options && options.delaySeconds);
         const list = [];
         let total = 0;
         for (const m of messages) {
+          if (__sbQueuesFixed() && (m == null || __sbQueueTypeName(m) !== "object"))
+            throw new TypeError("Incorrect type: the provided value is not of type 'MessageSendRequest'.");
           const item = m || {};
+          __sbQueueCheckDelay(item.delaySeconds);
           const encoded = __sbQueueEncode(item.body, item.contentType);
           total += encoded.size;
           // A message delay of 0 (or none) takes the batch delay, as miniflare does.
@@ -7043,6 +7356,11 @@ function __sbDOv2() {
   return __sbCompatDate() >= "2026-10-29";
 }
 
+// Storage, SQL, id and alarm behaviours that follow workerd more closely, from 2026-11-04.
+function __sbDOv3() {
+  return __sbCompatDate() >= "2026-11-04";
+}
+
 function __sbDOSha(text) {
   return __sbR2HexOf(__sbDigestRaw("256", __sbToBytes(text)));
 }
@@ -7052,7 +7370,27 @@ function __sbDOSeal(cls, body) {
   return body + __sbDOSha("sbdo-id:" + cls + ":" + body).slice(0, 16);
 }
 
+// workerd's DurableObjectId (2026-11-04): a class, so constructor.name and instanceof agree.
+if (globalThis.DurableObjectId == null) {
+  class DurableObjectId {
+    constructor(hex, name) {
+      this.name = name;
+      this.__sbHex = hex;
+    }
+    toString() {
+      return this.__sbHex;
+    }
+    equals(other) {
+      if (!(other instanceof DurableObjectId))
+        throw new TypeError("Failed to execute 'equals' on 'DurableObjectId': parameter 1 is not of type 'DurableObjectId'.");
+      return other.__sbHex === this.__sbHex;
+    }
+  }
+  globalThis.DurableObjectId = DurableObjectId;
+}
+
 function __sbDOMakeId(hex, name) {
+  if (__sbDOv3()) return new globalThis.DurableObjectId(hex, name);
   return {
     name,
     toString() {
@@ -7098,6 +7436,8 @@ function __sbMakeDONamespaceV2(className) {
       return __sbDOMakeId(__sbDOSeal(className, __sbDOHex(crypto.getRandomValues(new Uint8Array(24)))), undefined);
     },
     get(id) {
+      if (__sbDOv3() && !(id instanceof globalThis.DurableObjectId))
+        throw new TypeError("Failed to execute 'get' on 'DurableObjectNamespace': parameter 1 is not of type 'DurableObjectId'.");
       return __sbDOStub(className, __sbIsStr(id) ? ns.idFromString(id) : id);
     },
     getByName(name) {
@@ -7247,13 +7587,19 @@ function __sbGetDOInstance(cls, idText, idObj) {
     const __sbTasks = [];
     const gate = __sbDOMakeGate();
     const state = {
-      id: stateId || {
-        toString() {
-          return id;
-        },
-      },
+      id:
+        stateId ||
+        (__sbDOv3()
+          ? __sbDOMakeId(id, undefined)
+          : {
+              toString() {
+                return id;
+              },
+            }),
       storage: __sbDOGated() ? __sbDOAsyncStorage(cls, id, gate) : __sbDOStorage(cls, id),
       blockConcurrencyWhile(fn) {
+        if (__sbDOv3() && !__sbIsFn(fn))
+          throw new TypeError("Failed to execute 'blockConcurrencyWhile' on 'DurableObjectState': parameter 1 is not of type 'function'.");
         if (!__sbDOGated()) return fn();
         // No event enters until fn settles (2026-10-28).
         gate.locks++;
@@ -7283,6 +7629,15 @@ function __sbGetDOInstance(cls, idText, idObj) {
         if (p && __sbIsFn(p.then)) __sbTasks.push(p);
       },
     };
+    if (__sbDOv3()) {
+      state.props = {};
+      // Forgets this object's memory (the next request builds it afresh) and fails the event with
+      // the reason, as workerd's abort() does. Storage is kept.
+      state.abort = (reason) => {
+        __sbDOInstances[cacheKey] = undefined;
+        throw new Error(reason == null ? "Durable Object was aborted." : String(reason));
+      };
+    }
     // The hibernation API, from 2026-10-30 (where WebSocketPair exists).
     const holder = { inst: null, auto: null, cls, id, restored: [] };
     if (__sbWsEnabled()) __sbDOWebSocketState(state, holder);
@@ -7384,7 +7739,7 @@ function __sbDOGated() {
 }
 
 function __sbDOMakeGate() {
-  return { locks: 0, waiting: [] };
+  return { locks: 0, waiting: [], txnBusy: false, txnQueue: [] };
 }
 
 // Deliver queued events while the gate is open. A delivered event that reads storage shuts
@@ -7423,6 +7778,35 @@ function __sbDOEnter(gate, run) {
   });
 }
 
+// alarm(alarmInfo) from compatibility date 2026-11-04: { retryCount, isRetry }, as workerd
+// passes it. retryCount counts the runs of this alarm that threw or rejected. The three hosts
+// that deliver alarms (the broker, the embedded timer, sproutd) all end up in this prelude, so
+// the count lives here, on the object's instance and per scheduled time; it starts over when the alarm is set
+// for a new time or a run succeeds, and a host that knows its own count passes it as
+// attempts. A prelude that restarts between two runs counts from zero again.
+// (kept on the instance, as __sbAlarmAt and __sbAlarmFails)
+function __sbDOAlarmCall(inst, cls, id, at, attempts) {
+  if (__sbCompatDate() < "2026-11-04") return inst.alarm();
+  const when = Number(at) || 0;
+  if (inst.__sbAlarmAt !== when) {
+    inst.__sbAlarmAt = when;
+    inst.__sbAlarmFails = 0;
+  }
+  const retryCount = attempts != null && Number(attempts) > 0 ? Number(attempts) : inst.__sbAlarmFails;
+  return __sbDOAlarmRun(inst, { retryCount, isRetry: retryCount > 0 });
+}
+
+async function __sbDOAlarmRun(inst, info) {
+  try {
+    const res = inst.alarm(info);
+    if (res && __sbIsFn(res.then)) await res;
+  } catch (error) {
+    inst.__sbAlarmFails = inst.__sbAlarmFails + 1;
+    throw error;
+  }
+  inst.__sbAlarmFails = 0;
+}
+
 const __sbDOTag = "#sb1:";
 
 function __sbDOCloneError(value) {
@@ -7461,7 +7845,10 @@ function __sbDOView(name, bytes) {
 // else is an array whose first element names its type, so no plain value is ambiguous.
 /* oxlint-disable anti-slop/no-runtime-typeof -- structured clone branches on the value's type, as the HTML spec's StructuredSerialize does. */
 // fns (RPC only): functions go there, packed as ["F", index]; storage passes none.
-function __sbDOPack(v, seen, fns) {
+// refs (storage, 2026-11-04): an object met again is ["X", n], n its place in first-seen order, so
+// shared and circular references survive as structured clone keeps them; without it a circular
+// value throws and a shared one is copied.
+function __sbDOPack(v, seen, fns, refs) {
   if (v === null || v === true || v === false || __sbIsStr(v)) return v;
   const t = typeof v;
   if (t === "number") {
@@ -7476,19 +7863,23 @@ function __sbDOPack(v, seen, fns) {
   }
   if (t === "symbol") throw __sbDOCloneError(v.toString());
   if (t !== "object") throw __sbDOCloneError(v);
-  if (seen.indexOf(v) !== -1) throw __sbDOCloneError("a circular value");
+  const was = seen.indexOf(v);
+  if (was !== -1) {
+    if (refs) return ["X", was];
+    throw __sbDOCloneError("a circular value");
+  }
   seen.push(v);
   let out;
-  if (v instanceof Date) out = ["D", v.getTime()];
+  if (v instanceof Date) out = ["D", refs && Number.isNaN(v.getTime()) ? "NaN" : v.getTime()];
   else if (v instanceof Map) {
     out = ["M"];
     v.forEach((x, k) => {
-      out.push(__sbDOPack(k, seen, fns), __sbDOPack(x, seen, fns));
+      out.push(__sbDOPack(k, seen, fns, refs), __sbDOPack(x, seen, fns, refs));
     });
   } else if (v instanceof Set) {
     out = ["S"];
     v.forEach((x) => {
-      out.push(__sbDOPack(x, seen, fns));
+      out.push(__sbDOPack(x, seen, fns, refs));
     });
   } else if (v instanceof ArrayBuffer) out = ["AB", __sbDOHex(new Uint8Array(v))];
   else if (ArrayBuffer.isView(v)) {
@@ -7503,21 +7894,38 @@ function __sbDOPack(v, seen, fns) {
   else if (v instanceof RegExp) out = ["R", v.source, v.flags];
   else if (Array.isArray(v)) {
     out = ["A"];
-    for (let i = 0; i < v.length; i++) out.push(__sbDOPack(v[i], seen, fns));
+    for (let i = 0; i < v.length; i++) out.push(__sbDOPack(v[i], seen, fns, refs));
   } else if (v instanceof Error) out = ["E", String(v.name), String(v.message)];
   else {
     out = ["O"];
     const keys = Object.keys(v);
-    for (let i = 0; i < keys.length; i++) out.push(keys[i], __sbDOPack(v[keys[i]], seen, fns));
+    for (let i = 0; i < keys.length; i++) out.push(keys[i], __sbDOPack(v[keys[i]], seen, fns, refs));
   }
-  seen.pop();
+  if (!refs) seen.pop();
   return out;
 }
 /* oxlint-enable anti-slop/no-runtime-typeof */
 
-function __sbDOUnpack(p, fns) {
+// An error of the type its name says, for the names workerd's structured clone keeps.
+function __sbDOMakeError(name, message) {
+  if (__sbDOv3()) {
+    if (name === "TypeError") return new TypeError(message);
+    if (name === "RangeError") return new RangeError(message);
+    if (name === "SyntaxError") return new SyntaxError(message);
+    if (name === "ReferenceError") return new ReferenceError(message);
+    if (name === "EvalError") return new EvalError(message);
+    if (name === "URIError") return new URIError(message);
+  }
+  const e = new Error(message);
+  e.name = name;
+  return e;
+}
+
+// refs: the objects made so far in first-seen order (see __sbDOPack); undefined for RPC.
+function __sbDOUnpack(p, fns, refs) {
   if (!Array.isArray(p)) return p;
   const tag = p[0];
+  if (tag === "X") return refs[p[1]];
   if (tag === "U") return undefined;
   if (tag === "F" && fns) {
     const fn = fns[p[1]];
@@ -7525,49 +7933,82 @@ function __sbDOUnpack(p, fns) {
   }
   if (tag === "N") return p[1] === "-0" ? -0 : Number(p[1]);
   if (tag === "B") return BigInt(p[1]);
-  if (tag === "D") return new Date(p[1]);
-  if (tag === "AB") return __sbDOUnhex(p[1]).buffer;
-  if (tag === "V") return __sbDOView(p[1], __sbDOUnhex(p[2]));
-  if (tag === "R") return new RegExp(p[1], p[2]);
+  if (tag === "D") {
+    const d = new Date(p[1] === "NaN" ? NaN : p[1]);
+    if (refs) refs.push(d);
+    return d;
+  }
+  if (tag === "AB") {
+    const b = __sbDOUnhex(p[1]).buffer;
+    if (refs) refs.push(b);
+    return b;
+  }
+  if (tag === "V") {
+    const view = __sbDOView(p[1], __sbDOUnhex(p[2]));
+    if (refs) refs.push(view);
+    return view;
+  }
+  if (tag === "R") {
+    const r = new RegExp(p[1], p[2]);
+    if (refs) refs.push(r);
+    return r;
+  }
   if (tag === "E") {
-    const e = new Error(p[2]);
-    e.name = p[1];
+    const e = __sbDOMakeError(p[1], p[2]);
+    if (refs) refs.push(e);
     return e;
   }
   if (tag === "M") {
     const m = new Map();
-    for (let i = 1; i + 1 < p.length; i += 2) m.set(__sbDOUnpack(p[i], fns), __sbDOUnpack(p[i + 1], fns));
+    if (refs) refs.push(m);
+    for (let i = 1; i + 1 < p.length; i += 2) m.set(__sbDOUnpack(p[i], fns, refs), __sbDOUnpack(p[i + 1], fns, refs));
     return m;
   }
   if (tag === "S") {
     const s = new Set();
-    for (let i = 1; i < p.length; i++) s.add(__sbDOUnpack(p[i], fns));
+    if (refs) refs.push(s);
+    for (let i = 1; i < p.length; i++) s.add(__sbDOUnpack(p[i], fns, refs));
     return s;
   }
   if (tag === "A") {
     const a = [];
-    for (let i = 1; i < p.length; i++) a.push(__sbDOUnpack(p[i], fns));
+    if (refs) refs.push(a);
+    for (let i = 1; i < p.length; i++) a.push(__sbDOUnpack(p[i], fns, refs));
     return a;
   }
   const o = {};
-  for (let i = 1; i + 1 < p.length; i += 2) o[p[i]] = __sbDOUnpack(p[i + 1], fns);
+  if (refs) refs.push(o);
+  for (let i = 1; i + 1 < p.length; i += 2) o[p[i]] = __sbDOUnpack(p[i + 1], fns, refs);
   return o;
 }
 
 function __sbDOEncode(value) {
   if (value === undefined) throw new TypeError("put() called with undefined value.");
-  return __sbDOTag + JSON.stringify(__sbDOPack(value, []));
+  return __sbDOTag + JSON.stringify(__sbDOPack(value, [], undefined, __sbDOv3()));
 }
 
 // Reads both formats at every date: tagged (2026-10-28 writes) and plain JSON (earlier ones).
 function __sbDODecode(text) {
-  if (__sbIsStr(text) && text.indexOf(__sbDOTag) === 0) return __sbDOUnpack(JSON.parse(text.slice(__sbDOTag.length)));
+  if (__sbIsStr(text) && text.indexOf(__sbDOTag) === 0) return __sbDOUnpack(JSON.parse(text.slice(__sbDOTag.length)), undefined, []);
   return JSON.parse(text);
 }
 
 function __sbDOListLimit(options) {
   const o = options || {};
   if (o.limit != null && !(Number(o.limit) > 0)) throw new TypeError("List limit must be positive.");
+  if (__sbDOv3()) {
+    if (o.start != null && o.startAfter != null) throw new TypeError("list() cannot be called with both start and startAfter values.");
+    // A fractional limit counts whole entries (the datatype of a SQL LIMIT must be an integer).
+    if (o.limit != null)
+      return {
+        prefix: o.prefix,
+        start: o.start,
+        startAfter: o.startAfter,
+        end: o.end,
+        reverse: o.reverse,
+        limit: Math.max(1, Math.trunc(Number(o.limit))),
+      };
+  }
   return o;
 }
 
@@ -7579,6 +8020,31 @@ function __sbDOInRange(key, o) {
   return true;
 }
 
+// The keys of a multi-key get, in key order and without repeats.
+function __sbDOSortedKeys(keys) {
+  const out = [];
+  for (let i = 0; i < keys.length; i++) {
+    const k = String(keys[i]);
+    if (out.indexOf(k) === -1) out.push(k);
+  }
+  out.sort();
+  return out;
+}
+
+// put(key, value) and put({ key: value }) as [key, encoded] pairs (2026-11-04). An array or
+// undefined is no key; an entry whose value is undefined is skipped in the object form.
+function __sbDOPutPairs(key, value) {
+  if (key === undefined)
+    throw new TypeError("Failed to execute 'put' on 'DurableObjectStorage': parameter 1 is not of type 'string or object'.");
+  const pairs = [];
+  if (key !== null && __sbIsObj(key) && !Array.isArray(key)) {
+    // Encode every value before writing any, so one bad value writes nothing.
+    const keys = Object.keys(key);
+    for (let i = 0; i < keys.length; i++) if (key[keys[i]] !== undefined) pairs.push([keys[i], __sbDOEncode(key[keys[i]])]);
+  } else pairs.push([String(key), __sbDOEncode(value)]);
+  return pairs;
+}
+
 // The synchronous core of the 2026-10-28 storage: structured values, list() ranges.
 function __sbDOStrictStorage(cls, id) {
   const get = (key) => {
@@ -7593,13 +8059,20 @@ function __sbDOStrictStorage(cls, id) {
     get(key) {
       if (!Array.isArray(key)) return get(key);
       const out = new Map();
-      for (let i = 0; i < key.length; i++) {
-        const v = get(key[i]);
-        if (v !== undefined) out.set(key[i], v);
+      // workerd answers in key order, whatever the order asked.
+      const asked = __sbDOv3() ? __sbDOSortedKeys(key) : key;
+      for (let i = 0; i < asked.length; i++) {
+        const v = get(asked[i]);
+        if (v !== undefined) out.set(asked[i], v);
       }
       return out;
     },
     put(key, value) {
+      if (__sbDOv3()) {
+        const pairs = __sbDOPutPairs(key, value);
+        for (let i = 0; i < pairs.length; i++) __sbRpc("do.storage.put", { cls, id, key: pairs[i][0], value: pairs[i][1] });
+        return;
+      }
       if (key != null && __sbIsObj(key)) {
         // Encode every value before writing any, so one bad value writes nothing.
         const keys = Object.keys(key);
@@ -7623,6 +8096,15 @@ function __sbDOStrictStorage(cls, id) {
     },
     setAlarm(when) {
       const at = when instanceof Date ? when.getTime() : when;
+      if (__sbDOv3()) {
+        const inst = __sbDOInstances[cls + " " + id];
+        if (inst && !__sbIsFn(inst.alarm))
+          throw new TypeError("Your Durable Object class must have an alarm() handler in order to call setAlarm()");
+        if (when instanceof Date || Object(when) instanceof Number) {
+          if (!Number.isFinite(at)) throw new TypeError("The value cannot be converted because it is not a valid Date.");
+          if (at <= 0) throw new TypeError("setAlarm() cannot be called with an alarm time <= 0");
+        }
+      }
       if (!Number.isFinite(at))
         throw new TypeError("Failed to execute 'setAlarm' on 'DurableObjectStorage': parameter 1 is not of type 'date'.");
       __sbRpc("do.alarm.set", { cls, id, at: Number(at) });
@@ -7686,6 +8168,28 @@ function __sbDOAsyncStorage(cls, id, gate) {
     const sql = __sbDOSql(cls, id);
     storage.sql = sql;
     storage.transactionSync = (fn) => sql.__sbTransaction(fn);
+    if (__sbDOv3()) {
+      // deleteAll() on a SQLite-backed object drops its tables too.
+      storage.deleteAll = () =>
+        settle(() => {
+          s.deleteAll();
+          sql.__sbDropAll();
+        });
+      // The synchronous key-value API, over the same keys as get() and put().
+      storage.kv = {
+        get: (key) => s.get(key),
+        put: (key, value) => {
+          s.put(key, value);
+        },
+        delete: (key) => s.delete(key),
+        list: (options) => s.list(options).entries(),
+      };
+      // Point-in-time recovery needs the storage engine's log, which this one does not keep.
+      const pitr = () => Promise.reject(new Error("Point-in-time recovery is not supported by this Durable Object storage."));
+      storage.getCurrentBookmark = pitr;
+      storage.getBookmarkForTime = pitr;
+      storage.onNextSessionRestoreBookmark = pitr;
+    }
   }
   return storage;
 }
@@ -7724,6 +8228,135 @@ function __sbDOSqlVerb(q) {
   return q.slice(i, j).toUpperCase();
 }
 
+// exec() with several statements (compatibility date 2026-11-04). Splits the text at the
+// semicolons SQLite would, past quoted names and strings, comments, and the BEGIN ... END body
+// of CREATE TRIGGER. Statements with nothing in them but spaces and comments are dropped.
+// Returns { texts, params }: the statements' text, and for each 1 when it has a ? or a
+// :name, @name or $name outside quotes (which only the last statement may have), else 0.
+function __sbDOSqlSplit(q) {
+  const texts = [];
+  const params = [];
+  const n = q.length;
+  let start = 0;
+  let i = 0;
+  let words = 0; // keywords seen at this statement's top level, to spot CREATE TRIGGER
+  let trigger = false;
+  let inBody = false;
+  let cases = 0;
+  let param = false;
+  let content = false;
+  while (i <= n) {
+    const c = i < n ? q.charCodeAt(i) : 59;
+    if (c === 45 && q.charCodeAt(i + 1) === 45) {
+      const nl = q.indexOf("\n", i);
+      i = nl < 0 ? n : nl + 1;
+    } else if (c === 47 && q.charCodeAt(i + 1) === 42) {
+      const end = q.indexOf("*/", i + 2);
+      i = end < 0 ? n : end + 2;
+    } else if (c === 39 || c === 34 || c === 96 || c === 91) {
+      // 'string', "name", `name`, [name]: a doubled quote stays inside (not for [name]).
+      const close = c === 91 ? 93 : c;
+      content = true;
+      i++;
+      for (;;) {
+        if (i >= n) break;
+        if (q.charCodeAt(i) === close) {
+          if (close !== 93 && q.charCodeAt(i + 1) === close) i += 2;
+          else {
+            i++;
+            break;
+          }
+        } else i++;
+      }
+    } else if (c === 63 || c === 58 || c === 64 || c === 36) {
+      param = true;
+      content = true;
+      i++;
+    } else if ((c | 32) >= 97 && (c | 32) <= 122) {
+      let j = i;
+      while (j < n) {
+        const d = q.charCodeAt(j);
+        if (((d | 32) >= 97 && (d | 32) <= 122) || (d >= 48 && d <= 57) || d === 95 || d === 36) j++;
+        else break;
+      }
+      const word = q.slice(i, j).toUpperCase();
+      content = true;
+      if (words < 4 && !inBody) {
+        words++;
+        if (word === "TRIGGER") trigger = true;
+      }
+      if (trigger && word === "BEGIN") inBody = true;
+      else if (inBody && word === "CASE") cases++;
+      else if (inBody && word === "END") {
+        if (cases > 0) cases--;
+        else inBody = false;
+      }
+      i = j;
+    } else if (c === 59 && !inBody) {
+      if (content) {
+        texts.push(__sbDOSqlTrimStart(q.slice(start, i)));
+        params.push(param ? 1 : 0);
+      }
+      start = i + 1;
+      i++;
+      words = 0;
+      trigger = false;
+      cases = 0;
+      param = false;
+      content = false;
+    } else {
+      if (c > 32 && c !== 59) content = true;
+      i++;
+    }
+  }
+  if (content) {
+    texts.push(__sbDOSqlTrimStart(q.slice(start)));
+    params.push(param ? 1 : 0);
+  }
+  return { texts, params };
+}
+
+function __sbDOSqlTrimStart(text) {
+  let i = 0;
+  while (i < text.length && text.charCodeAt(i) <= 32) i++;
+  return i === 0 ? text : text.slice(i);
+}
+
+// A binding as workerd's sql.exec() takes it (2026-11-04): null and undefined are NULL, strings and
+// numbers themselves (NaN is NULL), binary data a BLOB, a BigInt is refused, and anything else
+// (booleans, Dates, objects, arrays) is its String(): true binds the text "true".
+function __sbDOSqlParam(v) {
+  if (v == null) return null;
+  if (__sbIsStr(v)) return v;
+  if (v instanceof ArrayBuffer || ArrayBuffer.isView(v)) return __sbD1Param(v, false);
+  if (Object(v) instanceof Number) return v !== v ? null : v;
+  /* oxlint-disable-next-line anti-slop/no-runtime-typeof -- a BigInt binding has its own error */
+  if (typeof v === "bigint") throw new TypeError("Cannot convert a BigInt value to a number");
+  return String(v);
+}
+
+const __sbDOSqlPragmas =
+  " foreign_keys table_list table_info table_xinfo index_list index_info index_xinfo foreign_key_list data_version " +
+  "defer_foreign_keys quick_check optimize case_sensitive_like recursive_triggers reverse_unordered_selects ";
+
+// What workerd's SQLite authorizer refuses (2026-11-04): other PRAGMAs, ATTACH, temporary tables,
+// VACUUM, and the functions that report the build. Throws the error workerd gives.
+function __sbDOSqlPolicy(text) {
+  const verb = __sbDOSqlVerb(text);
+  if (verb === "PRAGMA") {
+    const m = /pragma\s+(?:\w+\s*\.\s*)?(\w+)/i.exec(text);
+    if (!m || __sbDOSqlPragmas.indexOf(" " + m[1].toLowerCase() + " ") === -1) throw new Error("not authorized: SQLITE_AUTH");
+  } else if (verb === "ATTACH" || verb === "DETACH") throw new Error("not authorized: SQLITE_AUTH");
+  else if (verb === "VACUUM") throw new Error("cannot VACUUM from within a transaction: SQLITE_ERROR");
+  else if (verb === "CREATE" && /^\s*create\s+temp(orary)?\s/i.test(text)) throw new Error("not authorized: SQLITE_AUTH");
+  const f = /\b(sqlite_version|sqlite_source_id|sqlite_compileoption_used|sqlite_compileoption_get|fts5_source_id|load_extension)\s*\(/i.exec(text);
+  if (f) {
+    const name = f[1].toLowerCase();
+    if (name === "load_extension") throw new Error("not authorized: SQLITE_ERROR");
+    throw new Error("not authorized to use function: " + name + " at offset " + f.index + ": SQLITE_ERROR");
+  }
+}
+
 function __sbDOSql(cls, id) {
   const file = __sbDOIsHex64(id) ? id.toLowerCase() : __sbDOSha("sbdo-file:" + id);
   const run = (sql, params) => {
@@ -7743,9 +8376,50 @@ function __sbDOSql(cls, id) {
       if (verb === "BEGIN" || verb === "COMMIT" || verb === "END" || verb === "ROLLBACK" || verb === "SAVEPOINT" || verb === "RELEASE")
         throw new Error(__sbDOSqlTxnError);
       const params = [];
-      for (let i = 0; i < bindings.length; i++) params.push(__sbD1Param(bindings[i], true));
+      const v3 = __sbDOv3();
+      for (let i = 0; i < bindings.length; i++) params.push(v3 ? __sbDOSqlParam(bindings[i]) : __sbD1Param(bindings[i], true));
+      if (v3) {
+        // workerd runs every statement and the cursor is the last one's. Only that one may take
+        // parameters. A statement that fails stops the script; the ones before it stay done.
+        const split = __sbDOSqlSplit(q);
+        const parts = split.texts;
+        const hasParam = split.params;
+        if (parts.length === 0) throw new Error("SQL code did not contain a statement.");
+        for (let i = 0; i < parts.length - 1; i++)
+          if (hasParam[i] === 1) throw new Error("When executing multiple SQL statements in a single call, only the last statement can have parameters.");
+        for (let i = 0; i < parts.length; i++) {
+          const verb = __sbDOSqlVerb(parts[i]);
+          if (verb === "BEGIN" || verb === "COMMIT" || verb === "END" || verb === "ROLLBACK" || verb === "SAVEPOINT" || verb === "RELEASE")
+            throw new Error(__sbDOSqlTxnError);
+        }
+        let last = null;
+        for (let i = 0; i < parts.length; i++) {
+          __sbDOSqlPolicy(parts[i]);
+          last = run(parts[i], i === parts.length - 1 ? params : []);
+        }
+        return __sbDOCursor(last);
+      }
       return __sbDOCursor(run(q, params));
     },
+    // deleteAll() drops every table, view and trigger, as workerd does for a SQLite-backed object.
+    // A table another one refers to can refuse while that one is still there: go round again.
+    __sbDropAll() {
+      const quote = (name) => '"' + String(name).split('"').join('""') + '"';
+      for (let pass = 0; pass < 6; pass++) {
+        const rows = run("SELECT type, name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%' AND type IN ('view', 'trigger', 'table')", []).rows || [];
+        if (rows.length === 0) return;
+        let dropped = 0;
+        for (let i = 0; i < rows.length; i++) {
+          try {
+            run("DROP " + String(rows[i][0]).toUpperCase() + " IF EXISTS " + quote(rows[i][1]), []);
+            dropped++;
+          } catch {
+            /* a shadow table goes with its virtual table; one with a reference goes on a later pass */
+          }
+        }
+        if (dropped === 0) return;
+      }
+    },
     get databaseSize() {
       return Number(run("PRAGMA page_count", []).rows[0][0]) * Number(run("PRAGMA page_size", []).rows[0][0]);
     },
@@ -7780,6 +8454,9 @@ function __sbDOCursor(r) {
     return o;
   };
   const cursor = {
+    get [Symbol.toStringTag]() {
+      return "Cursor";
+    },
     columnNames: columns,
     rowsRead: rows.length,
     rowsWritten: Number(r.meta && r.meta.changes) || 0,
@@ -7814,7 +8491,15 @@ function __sbDOCursor(r) {
       return it;
     },
     [Symbol.iterator]() {
-      return cursor;
+      // workerd hands out a new iterator over the same rows (2026-11-04), not the cursor itself.
+      if (!__sbDOv3()) return cursor;
+      const it = {
+        next: () => cursor.next(),
+        [Symbol.iterator]() {
+          return it;
+        },
+      };
+      return it;
     },
   };
   return cursor;
@@ -7824,9 +8509,49 @@ function __sbDOCursor(r) {
 // memory (read back by its own get and list) and are written when fn resolves, unless it
 // threw or called txn.rollback(). The input gate stays shut meanwhile, so no other event
 // sees a half-written transaction.
+// From 2026-11-04 transactions on one object run one after another, so two that read, then
+// write the same key (a counter) do not lose an update; workerd gets that by retrying the loser.
+// A transaction() started inside another one waits for it, so it must not be awaited there.
 function __sbDOTransaction(cls, id, s, gate, fn) {
+  if (!__sbDOv3()) return __sbDOTransactionRun(cls, id, s, gate, fn);
+  if (!gate.txnBusy) {
+    gate.txnBusy = true;
+    return __sbDOTransactionStart(cls, id, s, gate, fn);
+  }
+  // Nothing but the waiting starts are kept on the gate, and they go once they have run.
+  return new Promise((resolve, reject) => {
+    gate.txnQueue.push(() => {
+      __sbDOTransactionStart(cls, id, s, gate, fn).then(resolve, reject);
+    });
+  });
+}
+
+function __sbDOTransactionStart(cls, id, s, gate, fn) {
+  const p = __sbDOTransactionRun(cls, id, s, gate, fn);
+  const next = () => {
+    if (gate.txnQueue.length > 0) gate.txnQueue.shift()();
+    else gate.txnBusy = false;
+  };
+  p.then(next, next);
+  return p;
+}
+
+function __sbDOTransactionRun(cls, id, s, gate, fn) {
   const writes = new Map(); // key -> encoded value, or null for a delete
   let rolledBack = false;
+  let committed = false;
+  const v3 = __sbDOv3();
+  // From 2026-11-04 workerd refuses a transaction used after txn.rollback() or after its closure
+  // finished; the refusal is a rejection naming the call.
+  const refused = (name) => {
+    if (!v3) return null;
+    if (rolledBack) return new Error("Cannot " + name + "() on rolled back transaction");
+    if (committed)
+      return new Error(
+        "Cannot call " + name + "() on transaction that has already committed: did you move `txn` outside of the closure?",
+      );
+    return null;
+  };
   const getOne = (key) => {
     const k = String(key);
     if (!writes.has(k)) return s.get(k);
@@ -7836,6 +8561,15 @@ function __sbDOTransaction(cls, id, s, gate, fn) {
   const putOne = (key, value) => {
     writes.set(String(key), __sbDOEncode(value));
   };
+  const putAny = (key, value) => {
+    if (v3) {
+      const pairs = __sbDOPutPairs(key, value);
+      for (let i = 0; i < pairs.length; i++) writes.set(pairs[i][0], pairs[i][1]);
+    } else if (key != null && __sbIsObj(key)) {
+      const keys = Object.keys(key);
+      for (let i = 0; i < keys.length; i++) putOne(keys[i], key[keys[i]]);
+    } else putOne(key, value);
+  };
   const delOne = (key) => {
     const existed = getOne(key) !== undefined;
     writes.set(String(key), null);
@@ -7843,32 +8577,38 @@ function __sbDOTransaction(cls, id, s, gate, fn) {
   };
   const txn = {
     get(key) {
+      const no = refused("get");
+      if (no) return Promise.reject(no);
       if (!Array.isArray(key)) return Promise.resolve(getOne(key));
       const out = new Map();
-      for (let i = 0; i < key.length; i++) {
-        const v = getOne(key[i]);
-        if (v !== undefined) out.set(key[i], v);
+      const asked = v3 ? __sbDOSortedKeys(key) : key;
+      for (let i = 0; i < asked.length; i++) {
+        const v = getOne(asked[i]);
+        if (v !== undefined) out.set(asked[i], v);
       }
       return Promise.resolve(out);
     },
     put(key, value) {
+      const no = refused("put");
+      if (no) return Promise.reject(no);
       try {
-        if (key != null && __sbIsObj(key)) {
-          const keys = Object.keys(key);
-          for (let i = 0; i < keys.length; i++) putOne(keys[i], key[keys[i]]);
-        } else putOne(key, value);
+        putAny(key, value);
         return Promise.resolve();
       } catch (error) {
         return Promise.reject(error);
       }
     },
     delete(key) {
+      const no = refused("delete");
+      if (no) return Promise.reject(no);
       if (!Array.isArray(key)) return Promise.resolve(delOne(key));
       let n = 0;
       for (let i = 0; i < key.length; i++) n += delOne(key[i]) ? 1 : 0;
       return Promise.resolve(n);
     },
     list(options) {
+      const no = refused("list");
+      if (no) return Promise.reject(no);
       try {
         const o = __sbDOListLimit(options);
         const merged = s.list({ prefix: o.prefix, start: o.start, startAfter: o.startAfter, end: o.end });
@@ -7892,10 +8632,31 @@ function __sbDOTransaction(cls, id, s, gate, fn) {
     rollback() {
       rolledBack = true;
     },
-    getAlarm: () => Promise.resolve(s.getAlarm()),
-    setAlarm: (when) => Promise.resolve(s.setAlarm(when)),
-    deleteAlarm: () => Promise.resolve(s.deleteAlarm()),
+    getAlarm() {
+      const no = refused("getAlarm");
+      if (no) return Promise.reject(no);
+      return Promise.resolve(s.getAlarm());
+    },
+    setAlarm(when) {
+      const no = refused("setAlarm");
+      if (no) return Promise.reject(no);
+      try {
+        return Promise.resolve(s.setAlarm(when));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    deleteAlarm() {
+      const no = refused("deleteAlarm");
+      if (no) return Promise.reject(no);
+      return Promise.resolve(s.deleteAlarm());
+    },
   };
+  // workerd has txn.deleteAll() and refuses it; earlier dates have no such method.
+  if (v3)
+    txn.deleteAll = function () {
+      return Promise.reject(new Error("Cannot call deleteAll() within a transaction"));
+    };
   gate.locks++;
   const done = () => {
     gate.locks--;
@@ -7910,6 +8671,7 @@ function __sbDOTransaction(cls, id, s, gate, fn) {
   }
   return Promise.resolve(r).then(
     (v) => {
+      committed = true;
       try {
         if (!rolledBack)
           writes.forEach((value, key) => {
@@ -7922,6 +8684,7 @@ function __sbDOTransaction(cls, id, s, gate, fn) {
       return v;
     },
     (error) => {
+      rolledBack = true;
       done();
       throw error;
     },
@@ -9160,7 +9923,7 @@ function __sbInstallWebSockets() {
   globalThis.WebSocketRequestResponsePair = __SbWebSocketRequestResponsePair;
 }
 
-async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top) {
+async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top, cpuCell) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
@@ -9178,6 +9941,12 @@ async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top) {
     // #179 — a rejected handler promise must not take the process down with it.
     r = __sbErrorResponse(error, bindingCall);
   }
+  // From 2026-11-02 an async handler reports its CPU too: the thread time of the slices in which this
+  // request ran, not its neighbours' (before it, only a handler that answered synchronously did).
+  if (cpuCell) {
+    if (__sbCompatDate() >= "2026-11-02") __sbTagCpu(r, __sbCpuTake(cpuCell));
+    __sbCpuEnd(cpuCell);
+  }
   // The response goes out now and ctx.waitUntil work keeps running after it, as in
   // workerd; it was awaited first, so a 1.5 s background task delayed the response by
   // 1.5 s. The 25 s cap still bounds it. Not called for no tasks: an async call is a coroutine and a promise.
@@ -9287,6 +10056,87 @@ globalThis.__sbOnUnhandledRejection = function (reason, promise) {
   }
 };
 
+// AsyncLocalStorage (node:async_hooks, as Workers has it: run, getStore, exit and the static snapshot
+// (no bind, enterWith or disable). The patched Porffor (toolchain async-context.ts) keeps one
+// "current context" value that every promise reaction, await and timer records when it is created and
+// sets when it runs. Here that value is a frame: the stores of the AsyncLocalStorage instances
+// entered so far, in two parallel arrays (a frame is never changed, run() makes a new one).
+function __sbCtxGet() {
+  let frame;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    frame = porf_unpack(porf_async_ctx_bits);
+  `;
+  return frame;
+}
+// oxlint-disable-next-line no-unused-vars -- `frame` is read inside the RawC block below, not by JS.
+function __sbCtxSet(frame) {
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    porf_async_ctx_bits = porf_pack(frame);
+  `;
+}
+function __sbFrameIndex(frame, als) {
+  if (!frame) return -1;
+  const keys = frame.keys;
+  for (let i = 0; i < keys.length; i++) if (keys[i] === als) return i;
+  return -1;
+}
+function __sbFrameWith(frame, als, store) {
+  const keys = [];
+  const vals = [];
+  if (frame) {
+    for (let i = 0; i < frame.keys.length; i++) {
+      if (frame.keys[i] === als) continue;
+      keys.push(frame.keys[i]);
+      vals.push(frame.vals[i]);
+    }
+  }
+  keys.push(als);
+  vals.push(store);
+  return { keys, vals };
+}
+function __sbRunInFrame(frame, fn, args) {
+  const previous = __sbCtxGet();
+  __sbCtxSet(frame);
+  try {
+    return fn.apply(undefined, args);
+  } finally {
+    __sbCtxSet(previous);
+  }
+}
+// A function constructor, not a class: Porffor refuses `new` on a class reached through an alias
+// (const { AsyncLocalStorage } = globalThis), which is how a bundled import arrives.
+function __SbAsyncLocalStorage() {}
+__SbAsyncLocalStorage.prototype.run = function (store, fn, ...args) {
+  if (!__sbIsFn(fn)) throw new TypeError("The \"callback\" argument must be of type function.");
+  return __sbRunInFrame(__sbFrameWith(__sbCtxGet(), this, store), fn, args);
+};
+__SbAsyncLocalStorage.prototype.exit = function (fn, ...args) {
+  if (!__sbIsFn(fn)) throw new TypeError("The \"callback\" argument must be of type function.");
+  return __sbRunInFrame(__sbFrameWith(__sbCtxGet(), this, undefined), fn, args);
+};
+__SbAsyncLocalStorage.prototype.getStore = function () {
+  const frame = __sbCtxGet();
+  const at = __sbFrameIndex(frame, this);
+  return at === -1 ? undefined : frame.vals[at];
+};
+__SbAsyncLocalStorage.prototype.enterWith = function () {
+  throw new Error("AsyncLocalStorage.enterWith() is not supported");
+};
+__SbAsyncLocalStorage.prototype.disable = function () {
+  throw new Error("AsyncLocalStorage.disable() is not supported");
+};
+// AsyncLocalStorage.bind(fn) is not provided: Porffor compiles a call of .bind on a function value to
+// Function.prototype.bind whatever properties the function has. snapshot() does the same job.
+__SbAsyncLocalStorage.snapshot = function () {
+  const frame = __sbCtxGet();
+  return function (fn, ...args) {
+    return __sbRunInFrame(frame, fn, args);
+  };
+};
+globalThis.AsyncLocalStorage = __SbAsyncLocalStorage;
+
 // Shared by alarm and scheduled: both reply with an empty 204 once their
 // handler (and anything it queued via `waitUntil`) has settled.
 async function __sb204WithDrain(res, tasks) {
@@ -9300,6 +10150,21 @@ async function __sb204WithDrain(res, tasks) {
   return new Response(null, { status: 204 });
 }
 
+// The alarm trigger's reply from 2026-11-04: 204 once alarm() and its waitUntil tasks have
+// settled, 500 if alarm() threw or rejected (the broker then retries it).
+async function __sbAlarmWithDrain(res, tasks) {
+  let failed = 0;
+  try {
+    if (res && __sbIsFn(res.then)) await res;
+  } catch (error) {
+    failed = 1;
+    __sbLogUncaught("alarm", error);
+  }
+  await __sbDrainWaitUntil(tasks);
+  if (failed === 1) return new Response("alarm failed", { status: 500 });
+  return new Response(null, { status: 204 });
+}
+
 async function __sbQueueWithDrain(result, tasks) {
   const r = result && __sbIsFn(result.then) ? await result : result;
   await __sbDrainWaitUntil(tasks);
@@ -9509,7 +10374,8 @@ globalThis.__sbEntry = function (handlers, request) {
     // itself returned, but never one derived from `.then()`, so chaining the
     // tag on hangs the request forever. cpuMs is documented as absent for
     // async handlers (see LogEvent in services/edge) — that is this.
-    const __t0 = __sbCpuMs();
+    const __cpuCell = __sbCpuBegin();
+    const __t0 = __cpuCell ? 0 : __sbCpuMs();
     const __sbTasks = [];
     const ctx = {
       waitUntil(p) {
@@ -9531,14 +10397,21 @@ globalThis.__sbEntry = function (handlers, request) {
     } catch (error) {
       // #179 — a synchronous throw anywhere in the handler must not take the
       // whole process (and every other in-flight request) down with it.
+      __sbCpuEnd(__cpuCell);
       return __sbErrorResponse(error, bindingCall);
     }
     // 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, false, true);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall, false, true, __cpuCell);
     // 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 (__sbHasWebSocket(__res)) {
+      __sbCpuEnd(__cpuCell);
+      return __sbWsHostResponse(__res);
+    }
+    // The request ran alone from start to here: its own slices, or the process delta where no slot was free.
+    const __cpu = __cpuCell ? __sbCpuTake(__cpuCell) : __sbCpuMs() - __t0;
+    __sbCpuEnd(__cpuCell);
+    return __sbTagCpu(__res, __cpu);
   }
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });
 
@@ -9586,23 +10459,31 @@ globalThis.__sbEntry = function (handlers, request) {
     // Always a promise now (`__sbRunQueueBatch` is async, to await the
     // handler above), so always tail-call the drain wrapper — same
     // promise-identity reasoning as `__sbFetchWithDrain`.
-    return __sbQueueWithDrain(__sbRunQueueBatch(__sbReceiver(handlers, ctx), __sbReadJson(request), ctx), __sbTasks);
+    return __sbQueueWithDrain(__sbRunQueueBatch(__sbReceiver(handlers, ctx), __sbReadJson(request, __sbQueuesFixed()), ctx), __sbTasks);
   }
 
   if (trigger === "alarm") {
     const body = __sbReadJson(request);
-    const inst = __sbGetDOInstance(String(body.cls || ""), String(body.id || ""));
+    const __acls = String(body.cls || "");
+    const __aid = String(body.id || "");
+    const inst = __sbGetDOInstance(__acls, __aid);
     if (!__sbIsFn(inst.alarm)) return new Response("no alarm handler", { status: 404 });
+    const __retries = __sbCompatDate() >= "2026-11-04";
     let __ares;
     try {
-      __ares = __sbDOGated() ? __sbDOEnter(inst.__sbGate, () => inst.alarm()) : inst.alarm();
+      __ares = __sbDOGated()
+        ? __sbDOEnter(inst.__sbGate, () => __sbDOAlarmCall(inst, __acls, __aid, body.scheduledTime, body.attempts))
+        : __sbDOAlarmCall(inst, __acls, __aid, body.scheduledTime, body.attempts);
     } catch (error) {
       // #179 — same rule as fetch: don't let a throw here crash the process.
       __sbLogUncaught("alarm", error);
+      // From 2026-11-04 a failed alarm answers 500, so the broker retries it as workerd does.
+      if (__retries) return new Response("alarm failed", { status: 500 });
       return new Response(null, { status: 204 });
     }
     // Was fire-and-forget before: an async `alarm()` and any `state.waitUntil()`
     // it queued were both dropped the moment 204 went out. Await both.
+    if (__retries) return __sbAlarmWithDrain(__ares, inst.__sbTasks);
     if (inst.__sbTasks.length || (__ares && __sbIsFn(__ares.then))) return __sb204WithDrain(__ares, inst.__sbTasks);
     return new Response(null, { status: 204 });
   }
@@ -9631,6 +10512,16 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
   const strict = __sbQueuesStrict();
   const binding = String(body.queue || "");
   const settings = __sbQueueSettings(binding);
+  if (__sbQueuesFixed()) {
+    // Tell the store this consumer follows the 2026-11-05 delivery rules, before the handler
+    // runs: a delivery that never comes back is then counted as a retry. An older broker
+    // doesn't know the call and keeps its own rules.
+    try {
+      __sbRpc("queue.consumer", { queue: binding });
+    } catch {
+      /* an older broker */
+    }
+  }
   const acked = [];
   const retried = [];
   // id -> seconds, from retry({ delaySeconds }) (2026-10-31)
@@ -9732,16 +10623,24 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
 // 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;
+  if (__sbQueuesFixed()) {
+    // Read-only data properties, as in workerd.
+    Object.defineProperty(this, "id", { value: String(m.id), enumerable: true, configurable: true, writable: false });
+    Object.defineProperty(this, "timestamp", { value: new Date(Number(m.timestamp) || Date.now()), enumerable: true, configurable: true, writable: false });
+    Object.defineProperty(this, "body", { value: decoded, enumerable: true, configurable: true, writable: false });
+    Object.defineProperty(this, "attempts", { value: Number(m.attempts) || 1, enumerable: true, configurable: true, writable: false });
+  } else {
+    this.id = String(m.id);
+    this.timestamp = new Date(Number(m.timestamp) || Date.now());
+    this.body = decoded;
+    this.attempts = Number(m.attempts) || 1;
+  }
   Object.defineProperty(this, "__sbDecide", { value: { ack, retry }, enumerable: false });
 }
 __SbQueueMessage.prototype.ack = function () {
@@ -9763,9 +10662,12 @@ __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) {
+function __sbReadJson(request, utf8) {
   try {
     const body = __sbRawBody(request);
+    // The native server hands over one character per byte; from 2026-11-05 a queue delivery
+    // decodes them as UTF-8 (non-ASCII message bodies used to arrive as mojibake).
+    if (utf8 && body != null && request._bodyLatin1 === true) return JSON.parse(__sbFromUtf8(String(body)));
     return JSON.parse(body == null ? "{}" : String(body));
   } catch {
     return {};