@sproutboat/wire 0.20.4 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @sproutboat/wire
 
+## 0.21.1
+
+### Patch Changes
+
+- Updated dependencies [3d576cd]
+  - @sproutboat/runtime@0.38.0
+
+## 0.21.0
+
+### Minor Changes
+
+- 1f0622b: Queues parity, from compatibility date 2026-11-05 (earlier dates answer as before). The v8 content type keeps shared and circular references, array holes and invalid dates, and an Error keeps its TypeError or RangeError type (it used to throw "a circular value could not be cloned", copy a shared object, fill holes with undefined and turn an invalid Date into 1970). A message's id, timestamp, body and attempts are read-only, as in workerd. send() and sendBatch() check arguments as workerd does: no arguments, an options argument that is not an object, a sendBatch item that is not an object, `bytes` given an ArrayBuffer (workerd takes an ArrayBufferView), and a delaySeconds outside 0 to 86400, which was clamped or kept. A delivery that never comes back (the worker died or timed out) now counts as a retry: the message is delivered at most max_retries + 1 times, and then goes to the dead letter queue, where it used to be retried up to 5 times and marked dead without reaching it. The consumer announces itself to the broker (`queue.consumer`) so the broker applies this only to apps on the new date. On the embedded transport a consumer that runs past the 30 s lease renews it, so its messages are no longer delivered twice with their acks lost.
+  
+  Over the broker (`sproutboat dev` and deployed apps) a queue delivery is now decoded as UTF-8 from 2026-11-05: a message body with non-ASCII text ("héllo ☃") used to reach the consumer as mojibake, because the native server hands the delivery over one character per byte.
+
+### Patch Changes
+
+- 4c4c25d: D1 answers like workerd in four more ways, from compatibility date 2026-11-03 (earlier dates answer exactly as before). A PRAGMA outside D1's allow-list (`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`; the name as written, schema `main` only) fails with `D1_ERROR: not authorized: SQLITE_AUTH`, in a query, a batch statement or an `exec()` line, on every transport; the check runs in the shim and only looks at a statement that starts with P (or a comment or `;`). `PRAGMA foreign_keys = OFF` no longer sticks in a standalone binary (D1 runs every call in a transaction, where it is a no-op). An `exec()` error reads `... : near "SELEC": syntax error at offset 0: SQLITE_ERROR`, with the offset counted from the failing statement and SQLite's result code (the embedded `sb_sql_script` now returns both; the broker counts statement starts itself, because bun:sqlite reports the offset in the whole string). A statement with nothing in it (`;`, a comment) fails with `SQL code did not contain a statement.`, and `exec("")` with `D1_EXEC_ERROR: Error in line 1: : No SQL statements detected.`. `prepare("A; B")` runs every statement and answers with the last one (all or nothing, `meta.changes` summed, only the last statement may take parameters, a tail of comments or `;;` is "SQL code did not contain a statement."); the embedded transport does it in C only when the first statement has a non-blank tail, so a single statement costs one `strlen`. On the broker transport every whole-number parameter binds as a REAL, as in workerd (`typeof(?)` is real, `7 / 2` is 3.5, a number in a TEXT column reads "7.0"), by wrapping the placeholder in `CAST(? AS REAL)`. `meta.rows_read` is unchanged: workerd counts rows scanned with Cloudflare's SQLite fork, which upstream SQLite cannot reproduce.
+- Updated dependencies [4c4c25d]
+- Updated dependencies [2c19adf]
+- Updated dependencies [354a405]
+- Updated dependencies [1f0622b]
+  - @sproutboat/runtime@0.37.0
+
 ## 0.20.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/wire",
-  "version": "0.20.4",
+  "version": "0.21.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,6 +23,6 @@
   },
   "dependencies": {
     "@sproutboat/assets": "^0.3.0",
-    "@sproutboat/runtime": "^0.36.0"
+    "@sproutboat/runtime": "^0.38.0"
   }
 }

package/src/broker.test.ts

@@ -1928,3 +1928,56 @@ test("listen(): a service.fetch body streamed in FRAME_V1_MORE frames reaches th
   socket.destroy();
   server.stop();
 });
+
+test("Queues 2026-11-05: a delivery that never comes back is a retry, and past max_retries goes to the dead letter queue", async () => {
+  const delivered: JsonObject[] = [];
+  const fetchImpl: FetchLike = async (_url, init) => {
+    delivered.push(obj(parseJsonValue(String(init?.body))));
+    throw new Error("the sprout died");
+  };
+  const b = make({
+    bindings: {
+      queues: ["JOBS", "DEAD"],
+      queueConfig: [
+        { binding: "JOBS", queue: "jobs", maxRetries: 1, deadLetterQueue: "dead" },
+        { binding: "DEAD", queue: "dead" },
+      ],
+    },
+    sproutUrl: "http://127.0.0.1:1/",
+    fetchImpl,
+    deliveryTimeoutMs: 100,
+    deliveryLeaseMs: 200,
+  });
+  await b.dispatch({ op: "queue.consumer", queue: "JOBS" });
+  await b.dispatch({ op: "queue.send", queue: "JOBS", body: "work" });
+  await Bun.sleep(2500);
+  // max_retries 1: two deliveries, then the dead letter queue (whose consumer is this sprout too).
+  expect(delivered.filter((d) => d.queue === "JOBS").length).toBe(2);
+  expect(delivered.filter((d) => d.queue === "DEAD").length).toBeGreaterThan(0);
+  expect(await b.dispatch({ op: "queue.metrics", queue: "JOBS" })).toMatchObject({ metrics: { backlogCount: 0 } });
+});
+
+test("Queues: without the 2026-11-05 announcement a lost delivery is retried after 5 s, as before", async () => {
+  const delivered: JsonObject[] = [];
+  const fetchImpl: FetchLike = async (_url, init) => {
+    delivered.push(obj(parseJsonValue(String(init?.body))));
+    throw new Error("the sprout died");
+  };
+  const b = make({
+    bindings: {
+      queues: ["JOBS", "DEAD"],
+      queueConfig: [
+        { binding: "JOBS", queue: "jobs", maxRetries: 1, deadLetterQueue: "dead" },
+        { binding: "DEAD", queue: "dead" },
+      ],
+    },
+    sproutUrl: "http://127.0.0.1:1/",
+    fetchImpl,
+    deliveryTimeoutMs: 100,
+    deliveryLeaseMs: 200,
+  });
+  await b.dispatch({ op: "queue.send", queue: "JOBS", body: "work" });
+  await Bun.sleep(1500);
+  expect(delivered.filter((d) => d.queue === "DEAD").length).toBe(0);
+  expect(delivered.filter((d) => d.queue === "JOBS").length).toBe(1);
+});

package/src/broker.ts

@@ -56,6 +56,9 @@ export type Bindings = {
     maxBatchSize?: number;
     maxBatchTimeout?: number;
     maxRetries?: number;
+    retryDelay?: number;
+    /** The queue name of this queue's dead letter queue. */
+    deadLetterQueue?: string;
   }>;
   analytics: string[];
   do: Array<{ binding: string; className: string }>;
@@ -678,6 +681,16 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
   const queueStore = (part: string): { store: Database; part: string } =>
     part.startsWith("#") ? { store: db, part } : storeFor("queue", requireQueue(part));
   const queueSettingsOf = (binding: string) => bindings.queueConfig?.find((q) => q.binding === binding);
+  /** Queue bindings whose sprout follows the 2026-11-05 delivery rules (see "queue.consumer"). */
+  const strictQueues = new Set<string>();
+  /** The partition of a queue binding's dead letter queue: its binding when the sprout binds that
+   *  queue, else "#name" (as the sprout computes it), or "" when there is none. */
+  const deadLetterPartOf = (binding: string): string => {
+    const name = queueSettingsOf(binding)?.deadLetterQueue;
+    if (name === undefined) return "";
+    const bound = bindings.queues.find((b) => (queueSettingsOf(b)?.queue ?? b) === name);
+    return bound ?? "#" + name;
+  };
   const requireAe = bound(bindings.analytics, "analytics dataset");
   const rateLimiterNames = bindings.ratelimiters.map((r) => r.binding);
   const requireRateLimiter = bound(rateLimiterNames, "rate limiter");
@@ -1801,6 +1814,12 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
           ? { ok: true, count: msgs.length, metrics: queueBacklog(store, q) }
           : { ok: true, count: msgs.length };
       }
+      case "queue.consumer": {
+        // A sprout from compatibility date 2026-11-05 announces its queue before its handler
+        // runs: from then on a delivery that never comes back counts as a retry.
+        strictQueues.add(requireQueue(msg.queue));
+        return { ok: true };
+      }
       case "queue.metrics": {
         const { store, part: q } = storeFor("queue", requireQueue(msg.queue));
         return { ok: true, metrics: queueBacklog(store, q) };
@@ -2256,11 +2275,44 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
       const wait = Math.max(0, Number(settings?.maxBatchTimeout) || 0) * 1000;
       // Deliveries that never came back (the sprout died or timed out each time) stop after
       // 5 attempts, or max_retries + 1 when that is more.
-      const cap = Math.max(QUEUE_MAX_ATTEMPTS, (settings?.maxRetries ?? 3) + 1);
+      const strict = strictQueues.has(binding);
+      const maxRetries = settings?.maxRetries ?? 3;
+      // From 2026-11-05 a lost delivery counts as a retry, so the cap is exactly max_retries + 1
+      // and the message goes to the dead letter queue like any other past it.
+      const cap = strict ? maxRetries + 1 : Math.max(QUEUE_MAX_ATTEMPTS, maxRetries + 1);
+      const deadPart = strict ? deadLetterPartOf(binding) : "";
       const now = Date.now();
       const claim = randomBytes(24).toString("hex");
       const rows = store
         .transaction(() => {
+          const lost = strict
+            ? store
+                .query<{ id: string; body: string; sent_at: number }, [string, number, number]>(
+                  "SELECT id, body, sent_at FROM mq WHERE queue = ? AND dead = 0 AND visible_at <= ? AND attempts >= ?",
+                )
+                .all(part, now, cap)
+            : [];
+          if (lost.length && deadPart) {
+            try {
+              const target = queueStore(deadPart);
+              for (const r of lost) {
+                if (target.store === store)
+                  store
+                    .query(
+                      "UPDATE mq SET queue = ?, visible_at = ?, attempts = 0, claim_token = '', dead = 0 WHERE queue = ? AND id = ?",
+                    )
+                    .run(target.part, now, part, r.id);
+                else {
+                  target.store
+                    .query("INSERT OR IGNORE INTO mq (queue, id, body, visible_at, sent_at) VALUES (?, ?, ?, ?, ?)")
+                    .run(target.part, r.id, r.body, now, r.sent_at);
+                  store.query("DELETE FROM mq WHERE queue = ? AND id = ?").run(part, r.id);
+                }
+              }
+            } catch {
+              // not a queue this broker serves: they are marked dead below, like a queue without one
+            }
+          }
           store
             .query("UPDATE mq SET dead = 1 WHERE queue = ? AND visible_at <= ? AND attempts >= ?")
             .run(part, now, cap);
@@ -2302,6 +2354,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
         let dead: string[] = [];
         let deadLetter = "";
         let delays: JsonObject | null = null;
+        let answered = false;
         if (res?.ok) {
           try {
             const parsed = jsonObject(parseJsonValue(await res.text()));
@@ -2314,6 +2367,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
             dead = (parsed && ids(parsed.dead)) ?? [];
             deadLetter = parsed && isString(parsed.deadLetter) ? parsed.deadLetter : "";
             delays = (parsed && jsonObject(parsed.delays ?? null)) ?? null;
+            answered = true;
           } catch {
             ack = [];
             retry = rows.map((r) => r.id);
@@ -2322,6 +2376,17 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
           ack = [];
           retry = rows.map((r) => r.id);
         }
+        if (strict && !answered) {
+          // No usable answer (the sprout timed out, died or sent garbage): from 2026-11-05 that is
+          // a retry like the sprout's own, with the queue's retry delay, and a message on its last
+          // allowed delivery goes to the dead letter queue.
+          const seconds = Math.max(0, Number(settings?.retryDelay) || 0);
+          const last = new Set(rows.filter((r) => r.attempts + 1 > maxRetries).map((r) => r.id));
+          dead = retry.filter((id) => last.has(id));
+          deadLetter = deadPart;
+          delays = Object.fromEntries(retry.filter((id) => !last.has(id)).map((id) => [id, seconds]));
+          retry = retry.filter((id) => !last.has(id));
+        }
         if (closed || !dispatchEnabled()) return;
         const retrySet = new Set(retry);
         const deadSet = new Set(dead);

package/src/d1.ts

@@ -64,10 +64,11 @@ const SQLITE_CODES = [
   "SQLITE_NOTADB",
 ];
 /** D1's wording for a SQLite error, as the embedded transport words it for strict calls. */
-export function d1Error(error: Error): Error {
+export function d1Error(error: Error, byteOffset?: number): Error {
   if (!isSqliteFailure(error)) return error;
   let text = `D1_ERROR: ${error.message}`;
-  if (Number.isInteger(error.byteOffset) && Number(error.byteOffset) >= 0) text += ` at offset ${error.byteOffset}`;
+  const offset = byteOffset ?? error.byteOffset;
+  if (Number.isInteger(offset) && Number(offset) >= 0) text += ` at offset ${offset}`;
   const base = SQLITE_CODES[(Number(error.errno) || 0) & 255];
   if (base) {
     text += `: ${base}`;
@@ -75,6 +76,160 @@ export function d1Error(error: Error): Error {
   }
   return new Error(text);
 }
+/**
+ * Where, in a line of statements, the statement that fails at byte `offset` begins. bun:sqlite counts an
+ * error's offset from the start of the whole string; D1 (SQLite's own exec loop) counts it from the first
+ * non-space character of the failing statement. A `;` inside a quoted name or string or a comment does not
+ * end a statement.
+ */
+export function statementStart(sql: Uint8Array, offset: number): number {
+  const at = (i: number) => (i < sql.length ? sql[i] : 0);
+  const space = (c: number) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+  let start = 0;
+  let i = 0;
+  while (i < offset) {
+    const c = sql[i];
+    if (c === 59) {
+      i++;
+      while (space(at(i))) i++;
+      if (i <= offset) start = i;
+    } else if (c === 39 || c === 34 || c === 96 || c === 91) {
+      const close = c === 91 ? 93 : c;
+      i++;
+      while (i < sql.length && sql[i] !== close) i++;
+      i++;
+    } else if (c === 45 && at(i + 1) === 45) {
+      while (i < sql.length && sql[i] !== 10) i++;
+    } else if (c === 47 && at(i + 1) === 42) {
+      i += 2;
+      while (i < sql.length && !(sql[i] === 42 && at(i + 1) === 47)) i++;
+      i += 2;
+    } else i++;
+  }
+  return start;
+}
+/** D1's text for the failure of one exec line (from 2026-11-03: with " at offset N: SQLITE_ERROR" and all). */
+function execLineError(error: Error, line: string): string {
+  const failure = error;
+  if (!isSqliteFailure(failure)) return failure.message;
+  const offset = Number(failure.byteOffset);
+  const own =
+    Number.isInteger(offset) && offset > 0
+      ? offset - statementStart(new TextEncoder().encode(line), offset)
+      : undefined;
+  return d1Error(failure, own).message.replace(/^D1_ERROR: /, "");
+}
+/** A parameter in SQL text: where it sits, and which bound value it takes. */
+type Placeholder = { start: number; end: number; index: number };
+const placeholderCache = new Map<string, Placeholder[]>();
+const isWordChar = (c: number) =>
+  (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || c === 95 || (c >= 97 && c <= 122) || c > 127;
+/** The position of the `;` that ends the first statement of `sql` (strings, quoted names and comments skipped), or -1. */
+export function firstSemicolon(sql: string): number {
+  for (let i = 0; i < sql.length; i++) {
+    const c = sql.charCodeAt(i);
+    if (c === 59) return i;
+    if (c === 39 || c === 34 || c === 96 || c === 91) {
+      const close = sql.indexOf(c === 91 ? "]" : sql[i]!, i + 1);
+      if (close < 0) return -1;
+      i = close;
+    } else if (c === 45 && sql.charCodeAt(i + 1) === 45) {
+      const nl = sql.indexOf("\n", i);
+      if (nl < 0) return -1;
+      i = nl;
+    } else if (c === 47 && sql.charCodeAt(i + 1) === 42) {
+      const close = sql.indexOf("*/", i + 2);
+      if (close < 0) return -1;
+      i = close + 1;
+    }
+  }
+  return -1;
+}
+function placeholders(sql: string): Placeholder[] {
+  const known = placeholderCache.get(sql);
+  if (known) return known;
+  const found: Placeholder[] = [];
+  const names = new Map<string, number>();
+  let max = 0;
+  for (let i = 0; i < sql.length; i++) {
+    const c = sql.charCodeAt(i);
+    if (c === 39 || c === 34 || c === 96 || c === 91) {
+      const close = sql.indexOf(c === 91 ? "]" : sql[i]!, i + 1);
+      if (close < 0) break;
+      i = close;
+    } else if (c === 45 && sql.charCodeAt(i + 1) === 45) {
+      const nl = sql.indexOf("\n", i);
+      if (nl < 0) break;
+      i = nl;
+    } else if (c === 47 && sql.charCodeAt(i + 1) === 42) {
+      const close = sql.indexOf("*/", i + 2);
+      if (close < 0) break;
+      i = close + 1;
+    } else if (c === 63) {
+      let end = i + 1;
+      while (end < sql.length && sql.charCodeAt(end) >= 48 && sql.charCodeAt(end) <= 57) end++;
+      const index = end > i + 1 ? Number(sql.slice(i + 1, end)) : max + 1;
+      max = Math.max(max, index);
+      found.push({ start: i, end, index });
+      i = end - 1;
+    } else if (c === 58 || c === 64 || c === 36) {
+      let end = i + 1;
+      while (end < sql.length && isWordChar(sql.charCodeAt(end))) end++;
+      if (end > i + 1) {
+        const name = sql.slice(i, end);
+        let index = names.get(name);
+        if (index === undefined) {
+          index = ++max;
+          names.set(name, index);
+        }
+        found.push({ start: i, end, index });
+        i = end - 1;
+      }
+    }
+  }
+  if (placeholderCache.size >= 256) {
+    const oldest = placeholderCache.keys().next();
+    if (!oldest.done) placeholderCache.delete(oldest.value);
+  }
+  placeholderCache.set(sql, found);
+  return found;
+}
+const REAL_PREFIX = "CAST(";
+const REAL_SUFFIX = " AS REAL)";
+/**
+ * workerd binds every JS number (and boolean) as a REAL; bun:sqlite binds a whole number as an INTEGER, and
+ * has no way to say otherwise. Wrap the placeholders that take one: `CAST(?1 AS REAL)` is the same value as
+ * the REAL SQLite would have been given, keeps an index lookup (`WHERE id = CAST(? AS REAL)` still searches
+ * the rowid) and reads `typeof(?)` as real, `7 / 2` as 3.5, and a number stored in a TEXT column as "7.0".
+ * `wraps` are the start offsets of the wrapped placeholders in the new text, to put an error offset back.
+ */
+export function bindReal(sql: string, values: SqlParam[]): { sql: string; wraps: number[] } | undefined {
+  let out: string | undefined;
+  let last = 0;
+  const wraps: number[] = [];
+  for (const p of placeholders(sql)) {
+    const v = values[p.index - 1];
+    if (!Number.isInteger(v)) continue;
+    out = (out ?? "") + sql.slice(last, p.start);
+    wraps.push(out.length);
+    out += REAL_PREFIX + sql.slice(p.start, p.end) + REAL_SUFFIX;
+    last = p.end;
+  }
+  return out === undefined ? undefined : { sql: out + sql.slice(last), wraps };
+}
+/** An error offset in bindReal's text, in the text the caller wrote. */
+function unwrapOffset(text: string, wraps: number[], offset: number): number {
+  let shift = 0;
+  for (const at of wraps) {
+    const start = Buffer.byteLength(text.slice(0, at));
+    if (offset < start) break;
+    shift += Math.min(offset - start, REAL_PREFIX.length);
+    const body = text.indexOf(" AS REAL)", at) - (at + REAL_PREFIX.length);
+    if (offset >= start + REAL_PREFIX.length + body)
+      shift += Math.min(offset - (start + REAL_PREFIX.length + body), REAL_SUFFIX.length);
+  }
+  return offset - shift;
+}
 export type D1Request = { owner: string; key: string; path: string; name: string; msg: Frame };
 
 /** maxOpen > 0 (Durable Object SQL, one file per object): at most that many connections stay
@@ -87,22 +242,79 @@ export function createD1Store(executionMs = 0, capability = "", maxOpen = 0) {
   // and rows come back as arrays with their column names.
   // A read changes nothing: changes() still holds the last write's count, total_changes() does not move.
   const total = (db: Database) => db.query<{ n: number }, []>("SELECT total_changes() AS n").get()?.n ?? 0;
-  const runStrict = (db: Database, sql: string, values: SqlParam[]) => {
+  type Statement = ReturnType<Database["query"]>;
+  // The text after statement's own (a statement bun:sqlite prepared; it ignores what follows): blank when it is
+  // the only one. Unbound, a statement's text is its own source; one with parameters can only be the last.
+  const tailOf = (statement: Statement, text: string) => {
+    const semi = text.indexOf(";");
+    if (semi < 0 || text.slice(semi + 1).trim() === "") return "";
+    let own = text;
+    if (statement.paramsCount === 0) own = statement.toString();
+    else {
+      const end = firstSemicolon(text);
+      if (end >= 0) own = text.slice(0, end + 1);
+    }
+    return text.startsWith(own) ? text.slice(own.length) : "";
+  };
+  const runStrict = (db: Database, sql: string, values: SqlParam[], parity = false) => {
     const started = performance.now();
     const before = total(db);
+    // 2026-11-03: numbers bind as REAL, as in workerd (see bindReal)
+    const real = parity ? bindReal(sql, values) : undefined;
+    const text = real ? real.sql : sql;
+    const fail = (e: Error) => {
+      const at = Number(isSqliteFailure(e) ? e.byteOffset : -1);
+      return d1Error(e, real && at >= 0 ? unwrapOffset(text, real.wraps, at) : undefined);
+    };
     let statement;
     try {
-      statement = db.query<SqliteValue[], SqlParam[]>(sql);
+      statement = db.query<SqliteValue[], SqlParam[]>(text);
     } catch (error) {
-      throw d1Error(error instanceof Error ? error : new Error(String(error)));
+      throw fail(error instanceof Error ? error : new Error(String(error)));
+    }
+    // 2026-11-03: a statement with more behind it runs them all and answers with the last, as workerd
+    // does (one savepoint: all or none), and only the last can take parameters.
+    const rest = parity ? tailOf(statement, text) : "";
+    let multi = false;
+    if (rest.trim() !== "") {
+      multi = true;
+      db.exec("SAVEPOINT sb_d1_multi");
     }
-    if (statement.paramsCount !== values.length)
-      throw new Error("D1_ERROR: Wrong number of parameter bindings for SQL query.");
     let rows: SqliteValue[][];
     try {
+      if (multi) {
+        let more = rest;
+        for (;;) {
+          more = more.trimStart();
+          if (more === "") break;
+          if (statement.paramsCount > 0)
+            throw new Error(
+              "D1_ERROR: When executing multiple SQL statements in a single call, only the last statement can have parameters.",
+            );
+          statement.run();
+          let next;
+          try {
+            next = db.query<SqliteValue[], SqlParam[]>(more);
+          } catch (error) {
+            // bun:sqlite has no statement to give for a tail of comments or semicolons
+            if (error instanceof Error && !isSqliteFailure(error))
+              throw new Error("D1_ERROR: SQL code did not contain a statement.");
+            throw error;
+          }
+          statement = next;
+          more = tailOf(next, more);
+        }
+      }
+      if (statement.paramsCount !== values.length)
+        throw new Error("D1_ERROR: Wrong number of parameter bindings for SQL query.");
       rows = statement.values(...values) ?? [];
+      if (multi) db.exec("RELEASE sb_d1_multi");
     } catch (error) {
-      throw d1Error(error instanceof Error ? error : new Error(String(error)));
+      if (multi) {
+        db.exec("ROLLBACK TO sb_d1_multi");
+        db.exec("RELEASE sb_d1_multi");
+      }
+      throw fail(error instanceof Error ? error : new Error(String(error)));
     }
     const meta = db
       .query<{ changes: number; last_row_id: number }, []>(
@@ -114,7 +326,7 @@ export function createD1Store(executionMs = 0, capability = "", maxOpen = 0) {
       rows: rows.map((row) => row.map((v) => cell(v, true))),
       meta: {
         duration: performance.now() - started,
-        changes: total(db) > before ? (meta?.changes ?? 0) : 0,
+        changes: multi ? total(db) - before : total(db) > before ? (meta?.changes ?? 0) : 0,
         last_row_id: meta?.last_row_id ?? 0,
         rows_read: rows.length,
       },
@@ -199,7 +411,10 @@ export function createD1Store(executionMs = 0, capability = "", maxOpen = 0) {
         // Foreign keys are enforced from compatibility date 2026-10-24, as in D1. The
         // pragma is per connection and a no-op inside a transaction, so set it per call.
         if (msg.op !== "d1.backup") db.exec(strict ? "PRAGMA foreign_keys = ON" : "PRAGMA foreign_keys = OFF");
-        const exec1 = strict ? runStrict : run;
+        const parity = msg.parity === true;
+        const exec1 = strict
+          ? (d: Database, sql: string, values: SqlParam[]) => runStrict(d, sql, values, parity)
+          : run;
         switch (msg.op) {
           case "d1.query":
             return { ok: true, ...exec1(db, str(msg.sql), params(msg.params)) };
@@ -216,7 +431,13 @@ export function createD1Store(executionMs = 0, capability = "", maxOpen = 0) {
                   db.exec(line);
                 } catch (error) {
                   throw new Error(
-                    `D1_EXEC_ERROR: Error in line ${i + 1}: ${line}: ${error instanceof Error ? error.message : String(error)}`,
+                    `D1_EXEC_ERROR: Error in line ${i + 1}: ${line}: ${
+                      msg.parity === true
+                        ? execLineError(error instanceof Error ? error : new Error(String(error)), line)
+                        : error instanceof Error
+                          ? error.message
+                          : String(error)
+                    }`,
                   );
                 }
               }),