@sproutboat/runtime 0.36.0 → 0.37.1

package/src/queues.test.js

@@ -157,3 +157,139 @@ test("before 2026-10-31 without settings, the outcome has only ack and retry", a
   expect(legacy).toEqual(["dlq", true, 5000]);
   expect(out).toEqual({ ack: [], retry: ["a"] });
 });
+
+// ---- 2026-11-05 ----
+
+const failure = (p) =>
+  p.then(
+    () => "accepted",
+    (e) => e.name + ": " + e.message,
+  );
+
+test("2026-11-05: send() checks arguments and delays as workerd does", async () => {
+  const { QUEUE } = env("2026-11-05");
+  expect(await failure(QUEUE.send())).toBe(
+    "TypeError: Failed to execute 'send' on 'WorkerQueue': parameter 1 is not of type 'JsValue'.",
+  );
+  expect(await failure(QUEUE.send(1, "x"))).toBe(
+    "TypeError: Failed to execute 'send' on 'WorkerQueue': parameter 2 is not of type 'SendOptions'.",
+  );
+  expect(await failure(QUEUE.send(1, null))).toBe("accepted");
+  expect(await failure(QUEUE.send(1, { delaySeconds: -1 }))).toStartWith("Error: Queue send failed: delaySeconds");
+  expect(await failure(QUEUE.send(1, { delaySeconds: 86401 }))).toStartWith("Error: Queue send failed: delaySeconds");
+  expect(await failure(QUEUE.send(1, { delaySeconds: 86400 }))).toBe("accepted");
+  expect(await failure(QUEUE.send(1, { delaySeconds: 1.5 }))).toBe("accepted");
+  expect(await failure(QUEUE.sendBatch([{ body: 1 }], { delaySeconds: 86401 }))).toStartWith(
+    "Error: Queue send failed",
+  );
+  expect(await failure(QUEUE.sendBatch([{ body: 1, delaySeconds: -5 }]))).toStartWith("Error: Queue send failed");
+  expect(await failure(QUEUE.sendBatch([1, 2]))).toBe(
+    "TypeError: Incorrect type: the provided value is not of type 'MessageSendRequest'.",
+  );
+  expect(await failure(QUEUE.send(new Uint8Array([1]).buffer, { contentType: "bytes" }))).toBe(
+    'TypeError: Content Type "bytes" requires a value of type ArrayBufferView, but received: object',
+  );
+  expect(await failure(QUEUE.send(new Uint8Array([1]), { contentType: "bytes" }))).toBe("accepted");
+});
+
+test("before 2026-11-05 the same arguments are accepted or answer as before", async () => {
+  const { QUEUE } = env("2026-11-01");
+  expect(await failure(QUEUE.send(1, { delaySeconds: 86401 }))).toBe("accepted");
+  expect(await failure(QUEUE.send(1, "x"))).toBe("accepted");
+  expect(await failure(QUEUE.sendBatch([{ body: 1, delaySeconds: -5 }]))).toBe("accepted");
+  expect(await failure(QUEUE.send(new Uint8Array([1]).buffer, { contentType: "bytes" }))).toBe("accepted");
+  expect(await failure(QUEUE.send())).toBe("TypeError: Message body cannot be undefined");
+  expect(sent.find((r) => r.delaySeconds === 86401)).toBeDefined();
+});
+
+const roundTrip = async (compat, value) => {
+  const { QUEUE } = env(compat);
+  await QUEUE.send(value, { contentType: "v8" });
+  const body = sent[sent.length - 1].body;
+  let seen;
+  await run(
+    {
+      queue(batch) {
+        seen = batch.messages[0];
+      },
+    },
+    { queue: "QUEUE", messages: [message("a", body)] },
+    ctx,
+  );
+  return { body, seen };
+};
+
+test("2026-11-05: the v8 content type keeps shared and circular references, holes and invalid dates", async () => {
+  const shared = { z: 1 };
+  const circular = { n: 1 };
+  circular.self = circular;
+  const holes = [1];
+  holes[3] = 4;
+  const { body, seen } = await roundTrip("2026-11-05", {
+    a: shared,
+    b: shared,
+    c: circular,
+    holes,
+    d: new Date(NaN),
+    e: new TypeError("boom"),
+    m: new Map([[shared, new Set([shared])]]),
+  });
+  expect(body.startsWith("#sbq1:v8r:")).toBe(true);
+  const v = seen.body;
+  expect(v.a).toBe(v.b);
+  expect(v.c.self).toBe(v.c);
+  expect(v.holes.length).toBe(4);
+  expect(1 in v.holes).toBe(false);
+  expect(v.holes[3]).toBe(4);
+  expect(Number.isNaN(v.d.getTime())).toBe(true);
+  expect(v.e).toBeInstanceOf(TypeError);
+  expect(v.e.message).toBe("boom");
+  const [key, set] = [...v.m][0];
+  expect(key).toBe(v.a);
+  expect([...set][0]).toBe(v.a);
+  expect(Object.getOwnPropertyDescriptor(seen, "body").writable).toBe(false);
+  expect(Object.getOwnPropertyDescriptor(seen, "id").writable).toBe(false);
+});
+
+test("before 2026-11-05 the v8 content type is the earlier codec, and v8r messages decode at any date", async () => {
+  const { body, seen } = await roundTrip("2026-11-01", { d: new Date(1000), m: new Map([[1, 2]]) });
+  expect(body.startsWith("#sbq1:v8:")).toBe(true);
+  expect(seen.body.m.get(1)).toBe(2);
+  const circular = {};
+  circular.self = circular;
+  const later = await roundTrip("2026-11-05", circular);
+  globalThis.__sbCompat = "2026-10-31";
+  let again;
+  await run(
+    {
+      queue(batch) {
+        again = batch.messages[0].body;
+      },
+    },
+    { queue: "QUEUE", messages: [message("a", later.body)] },
+    ctx,
+  );
+  expect(again.self).toBe(again);
+  expect(Object.getOwnPropertyDescriptor(seen, "body").writable).toBe(true);
+});
+
+test("2026-11-05: a consumer announces its queue to the store before the handler runs", async () => {
+  globalThis.__sbCompat = "2026-11-05";
+  sent = [];
+  let at;
+  await run(
+    {
+      queue() {
+        at = sent.length;
+      },
+    },
+    { queue: "QUEUE", messages: [message("a", "1")] },
+    ctx,
+  );
+  expect(sent[0]).toMatchObject({ op: "queue.consumer", queue: "QUEUE" });
+  expect(at).toBe(1);
+  globalThis.__sbCompat = "2026-11-01";
+  sent = [];
+  await run({ queue() {} }, { queue: "QUEUE", messages: [message("a", "1")] }, ctx);
+  expect(sent).toEqual([]);
+});

package/src/transport-embedded.js

@@ -61,6 +61,8 @@ extern int sqlite3_bind_parameter_count(sqlite3_stmt*);
 extern int sqlite3_stmt_readonly(sqlite3_stmt*);
 extern int sqlite3_extended_errcode(sqlite3*);
 extern int sqlite3_error_offset(sqlite3*);
+extern const char* sqlite3_sql(sqlite3_stmt*);
+extern int sqlite3_total_changes(sqlite3*);
 
 // baronunread/sproutboat#176 — defined in render.js, alongside
 // porf_native_fetch_read_value (which every inline-C block below already
@@ -2138,7 +2140,7 @@ static char* sb_sql_script(const char* path, const char* sql) {
   if (idx < 0 && sb_db_capture_failed(path)) { sb_puts(&b, "{\"ok\":false,\"error\":\"" SB_LTX_FAILED "\",\"code\":10}"); return b.p; }
   if (idx < 0) { sb_puts(&b, "{\"ok\":false,\"error\":\"cannot open database\"}"); return b.p; }
   char* err = 0;
-  int script_rc = 0, capture_failed = 0, quota_full = 0, failure_code = 0;
+  int script_rc = 0, capture_failed = 0, quota_full = 0, failure_code = 0, failure_offset = -1;
   char failure[512] = { 0 };
   if (sb_ltx_states[idx].db) {
     const char *next = sql;
@@ -2149,19 +2151,25 @@ static char* sb_sql_script(const char* path, const char* sql) {
       if (!script_rc && st) { do { script_rc = sqlite3_step(st); } while (script_rc == SB_SQLITE_ROW); if (script_rc == SB_SQLITE_DONE) script_rc = 0; }
       // Keep the statement's error before capture runs statements of its own (it would
       // read "not an error" after them).
-      if (script_rc && !failure[0]) { snprintf(failure, sizeof(failure), "%s", sqlite3_errmsg(sb_dbs[idx])); failure_code = sqlite3_extended_errcode(sb_dbs[idx]); }
+      if (script_rc && !failure[0]) { snprintf(failure, sizeof(failure), "%s", sqlite3_errmsg(sb_dbs[idx])); failure_code = sqlite3_extended_errcode(sb_dbs[idx]); failure_offset = sqlite3_error_offset(sb_dbs[idx]); }
       if (st) sqlite3_finalize(st);
       if (sb_ltx_after(idx)) { script_rc = 10; capture_failed = 1; }
       if (!tail || tail <= next) break;
       next = tail;
+      // as sqlite3_exec does: the next statement starts at its first non-space character, so an
+      // error offset counts from there
+      while (*next == ' ' || *next == '\t' || *next == '\n' || *next == '\r' || *next == '\f') next++;
     }
-  } else script_rc = sqlite3_exec(sb_dbs[idx], sql, 0, 0, &err);
+  } else {
+    script_rc = sqlite3_exec(sb_dbs[idx], sql, 0, 0, &err);
+    if (script_rc) { failure_code = sqlite3_extended_errcode(sb_dbs[idx]); failure_offset = sqlite3_error_offset(sb_dbs[idx]); }
+  }
   if (script_rc != 0) {
     const char* m = quota_full ? SB_QUOTA_FULL : capture_failed ? SB_LTX_FAILED : failure[0] ? failure : err ? err : sqlite3_errmsg(sb_dbs[idx]);
     sb_puts(&b, "{\"ok\":false,\"error\":");
     sb_putjson_text(&b, m, strlen(m));
     char code[32];
-    snprintf(code, sizeof(code), ",\"code\":%d}", quota_full ? 13 : capture_failed ? 10 : failure[0] ? failure_code : 0);
+    snprintf(code, sizeof(code), ",\"code\":%d,\"offset\":%d}", quota_full ? 13 : capture_failed ? 10 : failure_code, quota_full || capture_failed ? -1 : failure_offset);
     sb_puts(&b, code);
     return b.p;
   }
@@ -2187,6 +2195,39 @@ static char* sb_sql_error(sqlite3* db, const char* message, int code, int skip)
 // D1 calls from compatibility date 2026-10-24 put this comment first: the statement must
 // get exactly as many parameters as it has, like D1.
 #define SB_D1_STRICT "/*sb-d1-strict*/"
+// 2026-11-03: a statement with more behind it runs all of them, as workerd does (the marker follows
+// SB_D1_STRICT). A query without a tail never looks past its first statement.
+#define SB_D1_MULTI "/*sb-d1-multi*/"
+#define SB_MULTI_PARAMS "When executing multiple SQL statements in a single call, only the last statement can have parameters."
+#define SB_NO_STATEMENT "SQL code did not contain a statement."
+// Runs st (the first statement, cached) and every statement after it but the last, inside one
+// savepoint: they all take effect or none does. Returns the last statement, prepared here (the
+// caller finalizes it and ends the savepoint), or NULL with *error set (savepoint rolled back).
+static sqlite3_stmt* sb_multi_open(int idx, sqlite3* db, sqlite3_stmt* st, const char* rest, char** error) {
+  sqlite3_stmt* cur = st;
+  int cached = 1;
+  *error = 0;
+  sqlite3_exec(db, "SAVEPOINT sb_d1_multi", 0, 0, 0);
+  for (;;) {
+    rest = sb_skip_ws(rest);
+    if (!*rest) return cur;
+    if (sqlite3_bind_parameter_count(cur) > 0) { *error = sb_sql_error(db, SB_MULTI_PARAMS, 0, 0); break; }
+    if (sb_quota_frozen[idx] && !sqlite3_stmt_readonly(cur)) { *error = sb_sql_error(db, SB_QUOTA_FULL, 13, 0); break; }
+    int rc;
+    while ((rc = sqlite3_step(cur)) == SB_SQLITE_ROW) {}
+    if (rc != SB_SQLITE_DONE) { *error = sb_sql_error(db, 0, -1, 0); break; }
+    if (cached) sqlite3_reset(cur); else sqlite3_finalize(cur);
+    cur = 0;
+    sqlite3_stmt* next = 0; const char* tail = 0;
+    if (sqlite3_prepare_v2(db, rest, -1, &next, &tail)) { *error = sb_sql_error(db, 0, -1, 0); break; }
+    if (!next) { *error = sb_sql_error(db, SB_NO_STATEMENT, 0, 0); break; }
+    cur = next; cached = 0; rest = tail ? tail : "";
+  }
+  if (cur) { if (cached) sqlite3_reset(cur); else sqlite3_finalize(cur); }
+  sqlite3_exec(db, "ROLLBACK TO sb_d1_multi", 0, 0, 0);
+  sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0);
+  return 0;
+}
 
 // Run one statement. Returns malloc'd JSON:
 //   {"ok":true,"cols":[...],"rows":[[...]],"changes":n,"rowid":n}
@@ -2243,18 +2284,38 @@ static char* sb_sql_run_x(const char* path, const char* sql, const char* params,
   if (idx < 0) { sb_puts(&b, "{\"ok\":false,\"error\":\"cannot open database\"}"); return b.p; }
   sqlite3* db = sb_dbs[idx];
   const int strict = strncmp(sql, SB_D1_STRICT, sizeof(SB_D1_STRICT) - 1) == 0;
+  const int multi = strict && strncmp(sql + sizeof(SB_D1_STRICT) - 1, SB_D1_MULTI, sizeof(SB_D1_MULTI) - 1) == 0;
+  const int skip = strict ? (int)sizeof(SB_D1_STRICT) - 1 + (multi ? (int)sizeof(SB_D1_MULTI) - 1 : 0) : 0;
   // Durable Object SQL databases return BLOBs as D1 does.
   const int d1 = strstr(path, "/d1/") != 0 || sb_is_do_sql(path);
   sqlite3_stmt* st = sb_stmt_get(idx, db, sql);
-  if (!st) return sb_sql_error(db, 0, -1, strict ? (int)sizeof(SB_D1_STRICT) - 1 : 0);
+  if (!st) return sb_sql_error(db, 0, -1, skip);
+  // More than one statement: workerd runs them all and answers with the last one's rows; only the last
+  // can take parameters. (sqlite3_sql is the first statement's text, a prefix of sql.)
+  sqlite3_stmt* owned = 0;
+  long long multi_before = 0;
+  int in_multi = 0;
+  if (multi) {
+    const char* own = sqlite3_sql(st);
+    size_t olen = own ? strlen(own) : 0;
+    if (own && strncmp(sql, own, olen) == 0 && *sb_skip_ws(sql + olen)) {
+      char* merr = 0;
+      multi_before = sqlite3_total_changes(db);
+      owned = sb_multi_open(idx, db, st, sql + olen, &merr);
+      if (!owned) return merr;
+      st = owned; in_multi = 1;
+    }
+  }
   int bound = params && *params ? sb_bind_params(st, params) : 0;
   if (sb_quota_frozen[idx] && !sqlite3_stmt_readonly(st)) {
-    sqlite3_reset(st);
-    return sb_sql_error(db, SB_QUOTA_FULL, 13, 0);
+    char* e = sb_sql_error(db, SB_QUOTA_FULL, 13, 0);
+    if (owned) { sqlite3_finalize(owned); sqlite3_exec(db, "ROLLBACK TO sb_d1_multi", 0, 0, 0); sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0); } else sqlite3_reset(st);
+    return e;
   }
   if (strict && bound != sqlite3_bind_parameter_count(st)) {
-    sqlite3_reset(st);
-    return sb_sql_error(db, "Wrong number of parameter bindings for SQL query.", 0, 0);
+    char* e = sb_sql_error(db, "Wrong number of parameter bindings for SQL query.", 0, 0);
+    if (owned) { sqlite3_finalize(owned); sqlite3_exec(db, "ROLLBACK TO sb_d1_multi", 0, 0, 0); sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0); } else sqlite3_reset(st);
+    return e;
   }
 
   int ncol = sqlite3_column_count(st);
@@ -2330,25 +2391,41 @@ static char* sb_sql_run_x(const char* path, const char* sql, const char* params,
   }
   // A read-only statement changed nothing: sqlite3_changes still holds the last write's count.
   if (native) {
-    cells->changes = sqlite3_stmt_readonly(st) ? 0 : sqlite3_changes(db);
+    cells->changes = in_multi ? (int)(sqlite3_total_changes(db) - multi_before) : sqlite3_stmt_readonly(st) ? 0 : sqlite3_changes(db);
     cells->rowid = (long long)sqlite3_last_insert_rowid(db);
   } else {
     char tail[96];
-    int k = snprintf(tail, 96, "],\"changes\":%d,\"rowid\":%lld}", sqlite3_stmt_readonly(st) ? 0 : sqlite3_changes(db), (long long)sqlite3_last_insert_rowid(db));
+    int k = snprintf(tail, 96, "],\"changes\":%d,\"rowid\":%lld}", in_multi ? (int)(sqlite3_total_changes(db) - multi_before) : sqlite3_stmt_readonly(st) ? 0 : sqlite3_changes(db), (long long)sqlite3_last_insert_rowid(db));
     sb_put(&b, tail, (size_t)k);
   }
   // Reset, don't finalize: the statement stays compiled in sb_stmt_cache. Reset
   // now (not just on next reuse) so a SELECT stops holding its read transaction.
-  sqlite3_reset(st);
-  if (cells && cells->used < 0) { free(b.p); sb_cells_free(cells); return sb_sql_error(db, "out of memory", 7, 0); }
-  // The statement's own error, kept before LTX capture runs: capture executes statements
-  // of its own, after which SQLite reports "not an error".
+  // The statement's own error, kept before anything runs another statement (a rollback, LTX capture):
+  // after those SQLite reports "not an error".
   char failure[512] = { 0 };
   int failure_code = 0;
   if (rc != SB_SQLITE_DONE && rc != SB_SQLITE_ROW) {
     snprintf(failure, sizeof(failure), "%s", sqlite3_errmsg(db));
     failure_code = sqlite3_extended_errcode(db);
   }
+  sqlite3_reset(st);
+  if (owned) {
+    sqlite3_finalize(owned);
+    if (rc == SB_SQLITE_DONE || rc == SB_SQLITE_ROW) {
+      // a deferred constraint can fail here, as it does at COMMIT
+      if (sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0)) {
+        snprintf(failure, sizeof(failure), "%s", sqlite3_errmsg(db));
+        failure_code = sqlite3_extended_errcode(db);
+        rc = 1;
+        sqlite3_exec(db, "ROLLBACK TO sb_d1_multi", 0, 0, 0);
+        sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0);
+      }
+    } else {
+      sqlite3_exec(db, "ROLLBACK TO sb_d1_multi", 0, 0, 0);
+      sqlite3_exec(db, "RELEASE sb_d1_multi", 0, 0, 0);
+    }
+  }
+  if (cells && cells->used < 0) { free(b.p); sb_cells_free(cells); return sb_sql_error(db, "out of memory", 7, 0); }
   const int capture_failed = sb_ltx_after(idx) != 0;
   if (capture_failed) rc = 10;
   if (rc != SB_SQLITE_DONE && rc != SB_SQLITE_ROW) {
@@ -4878,7 +4955,7 @@ function __sbEmbeddedDispatch(msg) {
       __sbD1Open(path, msg.strict === true);
       __sbD1Quota(path);
       if (msg.strict === true && Array.isArray(msg.lines)) {
-        __sbD1ExecLines(path, msg.lines);
+        __sbD1ExecLines(path, msg.lines, msg.parity === true);
         return { ok: true };
       }
       const reply = JSON.parse(__sbSqlScriptRaw(path, String(msg.sql)));
@@ -4888,8 +4965,8 @@ function __sbEmbeddedDispatch(msg) {
     const strict = msg.strict === true;
     __sbD1Open(path, strict);
     __sbD1Quota(path);
-    if (op === "d1.batch") return { ok: true, results: __sbD1Batch(path, msg.statements || [], strict) };
-    const one = __sbD1Run(path, msg.sql, msg.params, strict);
+    if (op === "d1.batch") return { ok: true, results: __sbD1Batch(path, msg.statements || [], strict, msg.parity === true) };
+    const one = __sbD1Run(path, msg.sql, msg.params, strict, msg.parity === true);
     return { ok: true, results: one.results, columns: one.columns, rows: one.rows, native: one.native, meta: one.meta, success: true };
   }
 
@@ -5211,6 +5288,10 @@ function __sbEmbeddedDispatch(msg) {
 
   if (op === "queue.metrics") return { ok: true, metrics: __sbQueueBacklog(store, msg.queue) };
 
+  // A consumer announces itself (the broker uses it to pick the delivery rules of the app's
+  // compatibility date); the embedded store reads the date itself.
+  if (op === "queue.consumer") return { ok: true };
+
   if (op === "do.storage.get") {
     const r = __sbSql(store, "SELECT value FROM do_storage WHERE cls = ? AND id = ? AND key = ?", [
       msg.cls,
@@ -5436,10 +5517,10 @@ function __sbD1Bytes(cell) {
   for (let i = 0; i + 1 < hex.length; i += 2) out += String.fromCharCode(parseInt(hex.slice(i, i + 2), 16));
   return out;
 }
-function __sbD1Run(path, sql, params, strict) {
+function __sbD1Run(path, sql, params, strict, multi) {
   if (strict) {
     // Rows come back as arrays, built in C (see __sbSqlRowsRaw); the header is small JSON.
-    const pair = __sbSqlRowsRaw(path, "/*sb-d1-strict*/" + String(sql), JSON.stringify(params || []));
+    const pair = __sbSqlRowsRaw(path, multi ? "/*sb-d1-strict*//*sb-d1-multi*/" + String(sql) : "/*sb-d1-strict*/" + String(sql), JSON.stringify(params || []));
     if (pair[0] !== "") {
       const head = JSON.parse(pair[0]);
       if (head.ok === false) throw __sbD1Error(head);
@@ -5480,11 +5561,11 @@ function __sbD1Undo(path, savepoint) {
   return null;
 }
 // One transaction, like D1: a statement that fails undoes the ones before it.
-function __sbD1Batch(path, list, strict) {
+function __sbD1Batch(path, list, strict, multi) {
   const results = [];
   __sbD1Control(path, "SAVEPOINT sb_d1_batch", strict);
   try {
-    for (let i = 0; i < list.length; i++) results.push(__sbD1Run(path, list[i].sql, list[i].params, strict));
+    for (let i = 0; i < list.length; i++) results.push(__sbD1Run(path, list[i].sql, list[i].params, strict, multi));
   } catch (err) {
     __sbD1Undo(path, "sb_d1_batch");
     throw err;
@@ -5502,13 +5583,15 @@ function __sbD1Release(path, savepoint, strict) {
   throw strict ? __sbD1Error(r) : new Error("sqlite: " + r.error);
 }
 // exec() from 2026-10-24: line by line as workerd runs it, all or nothing.
-function __sbD1ExecLines(path, lines) {
+function __sbD1ExecLines(path, lines, parity) {
   __sbD1Control(path, "SAVEPOINT sb_d1_exec", true);
   for (let i = 0; i < lines.length; i++) {
     const reply = JSON.parse(__sbSqlScriptRaw(path, String(lines[i])));
     if (reply.ok === false) {
       if (Number(reply.code) !== 10) __sbD1Undo(path, "sb_d1_exec");
-      throw new Error("D1_EXEC_ERROR: Error in line " + (i + 1) + ": " + lines[i] + ": " + reply.error);
+      // parity (2026-11-03): D1's own wording after the line, " at offset N: SQLITE_ERROR" and all
+      const detail = parity ? __sbD1Error(reply).message.slice(10) : reply.error;
+      throw new Error("D1_EXEC_ERROR: Error in line " + (i + 1) + ": " + lines[i] + ": " + detail);
     }
   }
   __sbD1Release(path, "sb_d1_exec", true);
@@ -5618,7 +5701,7 @@ __sbD1QueryDirect = function (db, sql, params) {
   const path = __sbD1Path(String(db));
   __sbD1Open(path, true);
   __sbD1Quota(path);
-  return __sbD1Run(path, sql, params, true);
+  return __sbD1Run(path, sql, params, true, __sbCompatDate() >= "2026-11-03");
 };
 
 // The same dispatch without the JSON text either side: D1 calls take this (see __sbRpcDirect).
@@ -5695,7 +5778,9 @@ function __sbQueueBacklog(store, queue) {
 }
 
 function __sbQueueAttemptCap(settings) {
-  return Math.max(5, (settings.maxRetries !== undefined ? Number(settings.maxRetries) : 3) + 1);
+  const retries = (settings.maxRetries !== undefined ? Number(settings.maxRetries) : 3) + 1;
+  // From 2026-11-05 a lost delivery counts as a retry, so there is no floor of 5.
+  return __sbQueuesFixed() ? retries : Math.max(5, retries);
 }
 
 // How long a queue's due messages wait to fill a batch (max_batch_timeout), in ms.
@@ -5722,11 +5807,13 @@ async function __sbQueuePass(handlers, queues) {
     try {
       // A message whose deliveries never came back (the worker died or timed out each time)
       // stops after 5 attempts, or max_retries + 1 when that is more.
-      __sbSql(store, "UPDATE mq SET dead=1 WHERE queue=? AND visible_at<=? AND attempts>=?", [
-        name,
-        now,
-        __sbQueueAttemptCap(settings),
-      ]);
+      if (__sbQueuesFixed()) __sbQueueRetire(store, name, settings, now);
+      else
+        __sbSql(store, "UPDATE mq SET dead=1 WHERE queue=? AND visible_at<=? AND attempts>=?", [
+          name,
+          now,
+          __sbQueueAttemptCap(settings),
+        ]);
       due = __sbSql(
         store,
         "SELECT id,body,attempts,sent_at,visible_at FROM mq WHERE queue=? AND dead=0 AND visible_at<=? ORDER BY visible_at LIMIT ?",
@@ -5763,13 +5850,45 @@ async function __sbQueuePass(handlers, queues) {
         if (p && __sbIsFn(p.then)) __sbTasks.push(p);
       },
     };
-    let result = __sbRunQueueBatch(handlers, { queue: name, messages, metadata }, ctx);
-    if (result && __sbIsFn(result.then)) result = await result;
-    if (__sbTasks.length) await __sbDrainWaitUntil(__sbTasks);
+    // From 2026-11-05 a consumer that runs past the 30 s lease keeps its messages: the lease
+    // is renewed while it runs, so they are not delivered a second time or lose their ack.
+    const beat = __sbQueuesFixed()
+      ? setInterval(() => {
+          __sbSql(store, "UPDATE mq SET visible_at=? WHERE queue=? AND claim_token=? AND visible_at>?", [Date.now() + 30000, name, claim, Date.now()]);
+        }, 10000)
+      : null;
+    let result;
+    try {
+      result = __sbRunQueueBatch(handlers, { queue: name, messages, metadata }, ctx);
+      if (result && __sbIsFn(result.then)) result = await result;
+      if (__sbTasks.length) await __sbDrainWaitUntil(__sbTasks);
+    } finally {
+      if (beat !== null) clearInterval(beat);
+    }
     __sbQueueSettle(store, name, claim, result);
   }
 }
 
+// From 2026-11-05, the messages whose last allowed delivery never came back (the worker died or
+// timed out): they leave the queue as a message past max_retries does, into the dead letter
+// queue when there is one, or dropped. Runs inside the claim transaction.
+function __sbQueueRetire(store, name, settings, now) {
+  const rows = __sbSql(store, "SELECT id FROM mq WHERE queue=? AND dead=0 AND visible_at<=? AND attempts>=?", [
+    name,
+    now,
+    __sbQueueAttemptCap(settings),
+  ]).rows;
+  if (rows.length === 0) return;
+  if (settings.deadLetterQueue === undefined) {
+    __sbSql(store, "UPDATE mq SET dead=1 WHERE queue=? AND visible_at<=? AND attempts>=?", [name, now, __sbQueueAttemptCap(settings)]);
+    return;
+  }
+  const part = __sbQueuePart(settings.deadLetterQueue);
+  for (let i = 0; i < rows.length; i++)
+    __sbSql(store, "UPDATE mq SET queue=?,visible_at=?,attempts=0,claim_token='',dead=0 WHERE queue=? AND id=?", [part, now, name, rows[i][0]]);
+  if (__sbLocal !== null && __sbLocal.queues.indexOf(part) !== -1) __sbHostDue(now);
+}
+
 // Applies a batch's outcome to the claimed rows. `dead` (past max_retries) move to the dead
 // letter queue `deadLetter` as new messages, or are marked dead; `delays` gives each retry's
 // delay in seconds (5 when the runtime sends none). A row whose claim expired meanwhile was
@@ -5863,7 +5982,9 @@ async function __sbAlarmPass() {
     try {
       const instance = __sbGetDOInstance(cls, id);
       if (__sbIsFn(instance.alarm)) {
-        const res = __sbDOGated() ? __sbDOEnter(instance.__sbGate, () => instance.alarm()) : instance.alarm();
+        const res = __sbDOGated()
+          ? __sbDOEnter(instance.__sbGate, () => __sbDOAlarmCall(instance, cls, id, due.rows[i][2], null))
+          : __sbDOAlarmCall(instance, cls, id, due.rows[i][2], null);
         if (res && __sbIsFn(res.then)) await res;
         if (instance.__sbTasks.length) await __sbDrainWaitUntil(instance.__sbTasks);
       }

package/test/native-d1.ts

@@ -373,6 +373,77 @@ int main(void) {
     (e: Error) => e.message === 'D1_EXEC_ERROR: Error in line 2: SELEC 2: near "SELEC": syntax error',
   );
   assert.equal(ops.__sbD1Run(ex, "SELECT count(*) AS n FROM x", [], false).results[0].n, 2, "exec rolled back");
+  // From 2026-11-03 (parity): D1's text, with the failing statement's own offset (counted from its first
+  // non-space character) and SQLite's result code.
+  const parityError = (lines: string[]) => {
+    try {
+      ops.__sbD1ExecLines(ex, lines, true);
+    } catch (e) {
+      return e instanceof Error ? e.message : String(e);
+    }
+    return "did not throw";
+  };
+  const parityCases: [string[], string][] = [
+    [
+      ["INSERT INTO x VALUES (3); SELEC 2"],
+      'Error in line 1: INSERT INTO x VALUES (3); SELEC 2: near "SELEC": syntax error at offset 0: SQLITE_ERROR',
+    ],
+    [["SELEC 2"], 'Error in line 1: SELEC 2: near "SELEC": syntax error at offset 0: SQLITE_ERROR'],
+    [["SELECT 1;", "  SELEC 3"], 'Error in line 2:   SELEC 3: near "SELEC": syntax error at offset 2: SQLITE_ERROR'],
+    [["/*c*/ SELEC 1"], 'Error in line 1: /*c*/ SELEC 1: near "SELEC": syntax error at offset 6: SQLITE_ERROR'],
+    [["SELECT * FROM nope"], "Error in line 1: SELECT * FROM nope: no such table: nope: SQLITE_ERROR"],
+    [["SELECT 1,"], "Error in line 1: SELECT 1,: incomplete input: SQLITE_ERROR"],
+  ];
+  for (const [lines, text] of parityCases) assert.equal(parityError(lines), "D1_EXEC_ERROR: " + text);
+  ops.__sbD1ExecLines(ex, ["CREATE TABLE ux (a UNIQUE)", "INSERT INTO ux VALUES (1)"], true);
+  assert.equal(
+    parityError(["INSERT INTO ux VALUES (1)"]),
+    "D1_EXEC_ERROR: Error in line 1: INSERT INTO ux VALUES (1): UNIQUE constraint failed: ux.a: SQLITE_CONSTRAINT (extended: SQLITE_CONSTRAINT_UNIQUE)",
+  );
+  // From 2026-11-03 (multi): a statement with more behind it runs them all, in one savepoint, and answers with the last.
+  const mdb = join(work, "data/d1/MULTI.sqlite");
+  const multi = (sql: string, params: unknown[] = []) => ops.__sbD1Run(mdb, sql, params, true, true);
+  const multiError = (sql: string, params: unknown[] = []) => {
+    try {
+      multi(sql, params);
+    } catch (e) {
+      return e instanceof Error ? e.message : String(e);
+    }
+    return "did not throw";
+  };
+  multi("CREATE TABLE m (id INTEGER PRIMARY KEY, name TEXT, v TEXT UNIQUE)");
+  const two = multi("INSERT INTO m (id) VALUES (7); INSERT INTO m (id) VALUES (8)");
+  assert.deepEqual([two.meta.changes, two.meta.last_row_id, two.rows.length], [2, 8, 0]);
+  assert.equal(multi("INSERT INTO m (id) VALUES (10); UPDATE m SET name = 'x'").meta.changes, 4);
+  assert.deepEqual(multi("SELECT 1 AS a; SELECT 2 AS b").columns, ["b"]);
+  assert.deepEqual(multi("SELECT 1; SELECT ? AS p", [5]).rows, [[5]]);
+  assert.equal(multi("INSERT INTO m (id) VALUES (30); INSERT INTO m (id) VALUES (31); ").meta.changes, 2);
+  const mcount = () => ops.__sbD1Run(mdb, "SELECT count(*) FROM m", [], true, true).rows[0][0];
+  const mbefore = mcount();
+  assert.equal(
+    multiError("INSERT INTO m (id) VALUES (40); garbage"),
+    'D1_ERROR: near "garbage": syntax error at offset 0: SQLITE_ERROR',
+  );
+  assert.match(
+    multiError("INSERT INTO m (id, v) VALUES (41, 'a'); INSERT INTO m (id, v) VALUES (42, 'a')"),
+    /^D1_ERROR: UNIQUE constraint failed: m\.v: SQLITE_CONSTRAINT/,
+  );
+  assert.equal(
+    multiError("INSERT INTO m (id) VALUES (?); INSERT INTO m (id) VALUES (?)", [50, 51]),
+    "D1_ERROR: When executing multiple SQL statements in a single call, only the last statement can have parameters.",
+  );
+  assert.equal(multiError("SELECT 1;;"), "D1_ERROR: SQL code did not contain a statement.");
+  assert.equal(multiError("SELECT 1; -- c"), "D1_ERROR: SQL code did not contain a statement.");
+  assert.equal(
+    multiError("SELECT 1; SELECT ? AS p", [1, 2]),
+    "D1_ERROR: Wrong number of parameter bindings for SQL query.",
+  );
+  assert.equal(mcount(), mbefore, "a failing script left nothing behind");
+  assert.equal(
+    ops.__sbD1Run(mdb, "INSERT INTO m (id) VALUES (60); INSERT INTO m (id) VALUES (61)", [], true, false).meta.changes,
+    1,
+    "without multi only the first runs",
+  );
   const db2 = join(work, "data/d1/OPS.sqlite");
   ops.__sbD1Run(db2, "CREATE TABLE p (id INTEGER PRIMARY KEY)", [], false);
   ops.__sbD1Run(db2, "CREATE TABLE c (id INTEGER PRIMARY KEY, p INTEGER REFERENCES p(id))", [], false);