@delali/sirannon-db 0.3.5-next.71 → 0.3.5-next.72

package/dist/backup-scheduler/index.mjs

@@ -1,6 +1,6 @@
-export { BackupScheduler } from '../chunk-C53DPOR5.mjs';
+export { BackupScheduler } from '../chunk-BTUD6XQO.mjs';
 import '../chunk-W67A4H2E.mjs';
-import '../chunk-IWS4PJIO.mjs';
+import '../chunk-AHCMO4YL.mjs';
 import '../chunk-BUWJH3D3.mjs';
 import '../chunk-BGJ5JVYL.mjs';
 import '../chunk-HO2XTXVX.mjs';

package/dist/{chunk-IWS4PJIO.mjs → chunk-AHCMO4YL.mjs}

@@ -3,6 +3,7 @@ import { SirannonError } from './chunk-KINDFBQP.mjs';
 import { open } from 'fs/promises';
 
 var READ_CHUNK_BYTES = 4 * 1024 * 1024;
+var LOG_POSITION_READ_ATTEMPTS = 5;
 async function openForReading(path) {
   try {
     return await open(path, "r");
@@ -120,19 +121,27 @@ function logPathFor(sourcePath) {
 async function readLogPosition(sourcePath) {
   const logPath = logPathFor(sourcePath);
   try {
-    const header = await readLogFileHeader(logPath);
-    if (!header) return void 0;
-    const scan = await scanLogFrames(logPath, header, { frame: 0, checksum: header.checksum });
-    return {
-      logSequence: header.logSequence,
-      salt1: header.salt1,
-      salt2: header.salt2,
-      lastFrame: scan.lastCommitFrame
-    };
+    for (let attempt = 0; attempt < LOG_POSITION_READ_ATTEMPTS; attempt++) {
+      const header = await readLogFileHeader(logPath);
+      if (!header) return void 0;
+      const scan = await scanLogFrames(logPath, header, { frame: 0, checksum: header.checksum });
+      const headerAfterScan = await readLogFileHeader(logPath);
+      if (headerAfterScan === void 0 || !sameGeneration(header, headerAfterScan)) continue;
+      return {
+        logSequence: header.logSequence,
+        salt1: header.salt1,
+        salt2: header.salt2,
+        lastFrame: scan.lastCommitFrame
+      };
+    }
+    return void 0;
   } catch {
     return void 0;
   }
 }
+function sameGeneration(first, second) {
+  return first.logSequence === second.logSequence && first.salt1 === second.salt1 && first.salt2 === second.salt2;
+}
 function cursorChecksum(cursor) {
   return { first: cursor.checksum1, second: cursor.checksum2 };
 }

package/dist/{chunk-YRNLEOSU.mjs → chunk-AP4367HK.mjs}

@@ -1,8 +1,8 @@
 import { record, string, unknown, object, optional, nullable, picklist, safeParse, summarize } from './chunk-ZFFUVYYE.mjs';
-import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-LHH4PMRV.mjs';
-import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-56HOLQKD.mjs';
+import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-DDIHBUEN.mjs';
+import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-RPWBYASV.mjs';
 import { BatchValidationError, ConflictError, ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-EUNHTFR7.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-JFVEGN7J.mjs';
 import { sha256Hex } from './chunk-GVCNMPOS.mjs';
 import { lateRowCountsOf } from './chunk-K43WJORM.mjs';
 import { rowCountsOf, totalRowCounts, addRowCounts } from './chunk-E2GRX4ZD.mjs';

package/dist/{chunk-C53DPOR5.mjs → chunk-BTUD6XQO.mjs}

@@ -1,5 +1,5 @@
 import { startCopyWithoutHoldingWriter } from './chunk-W67A4H2E.mjs';
-import { readLogPosition } from './chunk-IWS4PJIO.mjs';
+import { readLogPosition } from './chunk-AHCMO4YL.mjs';
 import { reportQuietly } from './chunk-BUWJH3D3.mjs';
 import { randomHex, destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS, assertDeadline, withinDeadline } from './chunk-BGJ5JVYL.mjs';
 import { invokeCallerCallback } from './chunk-HO2XTXVX.mjs';

package/dist/{chunk-N4EXO2VH.mjs → chunk-DBN57KVR.mjs}

@@ -35,6 +35,60 @@ function defineDriver(config) {
   });
 }
 
+// src/core/driver/statement-text.ts
+var SPACE = 32;
+var TAB = 9;
+var LINE_FEED = 10;
+var VERTICAL_TAB = 11;
+var FORM_FEED = 12;
+var CARRIAGE_RETURN = 13;
+var SEMICOLON = 59;
+var HYPHEN = 45;
+var SLASH = 47;
+var ASTERISK = 42;
+var NO_STATEMENT_MESSAGE = "The supplied SQL string contains no statements";
+function startsSqliteSpace(code) {
+  return code === SPACE || code === TAB || code === LINE_FEED || code === FORM_FEED || code === CARRIAGE_RETURN;
+}
+function continuesSqliteSpace(code) {
+  return startsSqliteSpace(code) || code === VERTICAL_TAB;
+}
+function holdsNoStatement(sql) {
+  const firstNul = sql.indexOf("\0");
+  const text = firstNul === -1 ? sql : sql.slice(0, firstNul);
+  let index = 0;
+  while (index < text.length) {
+    const code = text.charCodeAt(index);
+    if (startsSqliteSpace(code)) {
+      index++;
+      while (index < text.length && continuesSqliteSpace(text.charCodeAt(index))) index++;
+      continue;
+    }
+    if (code === SEMICOLON) {
+      index++;
+      continue;
+    }
+    const next = text.charCodeAt(index + 1);
+    if (code === HYPHEN && next === HYPHEN) {
+      const lineEnd = text.indexOf("\n", index + 2);
+      if (lineEnd === -1) return true;
+      index = lineEnd;
+      continue;
+    }
+    if (code === SLASH && next === ASTERISK && index + 2 < text.length) {
+      const commentEnd = text.indexOf("*/", index + 2);
+      if (commentEnd === -1) return true;
+      index = commentEnd + 2;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function assertHoldsStatement(sql) {
+  if (holdsNoStatement(sql)) throw new RangeError(NO_STATEMENT_MESSAGE);
+}
+
 // src/core/driver/synchronous.ts
 var DEFAULT_SYNCHRONOUS = "normal";
 var SYNCHRONOUS_PRAGMA_VALUES = {
@@ -114,4 +168,4 @@ function bindableParams(params) {
   return bound ?? params;
 }
 
-export { ExtensionError, SirannonError, bindableParams, defineDriver, isNamedParams, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, synchronousPragmaValue };
+export { ExtensionError, SirannonError, assertHoldsStatement, bindableParams, defineDriver, isNamedParams, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, synchronousPragmaValue };

package/dist/{chunk-LHH4PMRV.mjs → chunk-DDIHBUEN.mjs}

@@ -1,37 +1,63 @@
-import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-EUNHTFR7.mjs';
+import { encodeWireRowsInPlace, assertSqlAllowed } from './chunk-JFVEGN7J.mjs';
 import { withRowCounts, rowCountsOf, allMetered, addRowCounts } from './chunk-E2GRX4ZD.mjs';
 import { SirannonError, QueryError, TransactionError } from './chunk-KINDFBQP.mjs';
 
-// src/core/query-executor.ts
+// src/core/prepared-statements.ts
 var STATEMENT_CACHE_CAPACITY = 128;
 var statementCaches = /* @__PURE__ */ new WeakMap();
-async function getStatement(conn, sql) {
+function cacheOf(conn) {
   let cache = statementCaches.get(conn);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
+  if (cache === void 0) {
+    cache = { entries: /* @__PURE__ */ new Map(), newest: void 0 };
     statementCaches.set(conn, cache);
   }
-  const cached = cache.get(sql);
-  if (cached) {
-    cache.delete(sql);
-    cache.set(sql, cached);
-    return cached;
-  }
-  const pending = conn.prepare(sql);
-  cache.set(sql, pending);
-  if (cache.size > STATEMENT_CACHE_CAPACITY) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) {
-      cache.delete(oldest);
+  return cache;
+}
+function lookUp(cache, sql) {
+  const entry = cache.entries.get(sql);
+  if (entry === void 0 || cache.newest === sql) return entry;
+  cache.entries.delete(sql);
+  cache.entries.set(sql, entry);
+  cache.newest = sql;
+  return entry;
+}
+function prepareInto(cache, conn, sql) {
+  const entry = { pending: conn.prepare(sql), prepared: void 0, passedSqlGuard: false };
+  cache.entries.set(sql, entry);
+  cache.newest = sql;
+  if (cache.entries.size > STATEMENT_CACHE_CAPACITY) {
+    const oldest = cache.entries.keys().next().value;
+    if (oldest !== void 0) cache.entries.delete(oldest);
+  }
+  entry.pending.then(
+    (statement) => {
+      entry.prepared = statement;
+    },
+    () => {
+      if (cache.entries.get(sql) === entry) cache.entries.delete(sql);
+      if (cache.newest === sql) cache.newest = void 0;
     }
-  }
-  try {
-    return await pending;
-  } catch (err) {
-    cache.delete(sql);
-    throw err;
-  }
+  );
+  return entry;
+}
+function statementOf(entry) {
+  return entry.prepared ?? entry.pending;
 }
+function trustedStatement(conn, sql) {
+  const cache = cacheOf(conn);
+  return statementOf(lookUp(cache, sql) ?? prepareInto(cache, conn, sql));
+}
+function guardedStatement(conn, sql) {
+  const cache = cacheOf(conn);
+  const cached = lookUp(cache, sql);
+  if (cached?.passedSqlGuard) return statementOf(cached);
+  assertSqlAllowed(sql);
+  const entry = cached ?? prepareInto(cache, conn, sql);
+  entry.passedSqlGuard = true;
+  return statementOf(entry);
+}
+
+// src/core/query-executor.ts
 function bindParams(params) {
   if (params === void 0) return [];
   if (Array.isArray(params)) return params;
@@ -49,20 +75,24 @@ function metered(value, counts) {
   return counts === void 0 ? { value } : { value, rowsRead: counts.rowsRead, rowsWritten: counts.rowsWritten };
 }
 async function query(conn, sql, params) {
-  return (await queryMetered(conn, sql, params)).value;
+  try {
+    const handle = guardedStatement(conn, sql);
+    const stmt = handle instanceof Promise ? await handle : handle;
+    return await stmt.all(...bindParams(params));
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
 }
 async function queryMetered(conn, sql, params) {
-  assertSqlAllowed(sql);
   try {
-    return await allMetered(await getStatement(conn, sql), bindParams(params));
+    return await allMetered(await guardedStatement(conn, sql), bindParams(params));
   } catch (err) {
     throw asQueryError(err, sql);
   }
 }
 async function queryForWire(conn, sql, params) {
-  assertSqlAllowed(sql);
   try {
-    const stmt = await getStatement(conn, sql);
+    const stmt = await guardedStatement(conn, sql);
     const bound = bindParams(params);
     const counted = stmt.allRaw ? stmt.allRawCounted : stmt.allCounted;
     if (counted) {
@@ -75,13 +105,29 @@ async function queryForWire(conn, sql, params) {
     throw asQueryError(err, sql);
   }
 }
+async function queryRowsForWire(conn, sql, params) {
+  try {
+    const handle = guardedStatement(conn, sql);
+    const stmt = handle instanceof Promise ? await handle : handle;
+    const bound = bindParams(params);
+    const rows = stmt.allRaw ? await stmt.allRaw(...bound) : await stmt.all(...bound);
+    return encodeWireRowsInPlace(rows);
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
+}
 async function queryOne(conn, sql, params) {
-  return (await queryOneMetered(conn, sql, params)).value;
+  try {
+    const handle = guardedStatement(conn, sql);
+    const stmt = handle instanceof Promise ? await handle : handle;
+    return await stmt.get(...bindParams(params));
+  } catch (err) {
+    throw asQueryError(err, sql);
+  }
 }
 async function queryOneMetered(conn, sql, params) {
-  assertSqlAllowed(sql);
   try {
-    const stmt = await getStatement(conn, sql);
+    const stmt = await guardedStatement(conn, sql);
     const bound = bindParams(params);
     if (stmt.getCounted) return await stmt.getCounted(...bound);
     return { value: await stmt.get(...bound) };
@@ -90,11 +136,9 @@ async function queryOneMetered(conn, sql, params) {
   }
 }
 async function execute(conn, sql, params, trusted = false) {
-  if (!trusted) {
-    assertSqlAllowed(sql);
-  }
   try {
-    const stmt = await getStatement(conn, sql);
+    const handle = trusted ? trustedStatement(conn, sql) : guardedStatement(conn, sql);
+    const stmt = handle instanceof Promise ? await handle : handle;
     const result = await stmt.run(...bindParams(params));
     return withRowCounts({ changes: result.changes, lastInsertRowId: result.lastInsertRowId }, rowCountsOf(result));
   } catch (err) {
@@ -102,10 +146,9 @@ async function execute(conn, sql, params, trusted = false) {
   }
 }
 async function forEachBatchRow(conn, sql, paramsBatch, sink) {
-  assertSqlAllowed(sql);
   let counts;
   try {
-    const stmt = await getStatement(conn, sql);
+    const stmt = await guardedStatement(conn, sql);
     for (const params of paramsBatch) {
       const result = await stmt.run(...bindParams(params));
       counts = addRowCounts(counts, rowCountsOf(result));
@@ -194,4 +237,4 @@ async function runInSavepoint(conn, body) {
   return value;
 }
 
-export { asQueryError, bindParams, commitFailure, execute, executeBatch, executeBatchSummary, query, queryForWire, queryMetered, queryOne, queryOneMetered, runInSavepoint, runWriterTransaction, withoutRowCounts };
+export { asQueryError, bindParams, commitFailure, execute, executeBatch, executeBatchSummary, query, queryForWire, queryMetered, queryOne, queryOneMetered, queryRowsForWire, runInSavepoint, runWriterTransaction, withoutRowCounts };

package/dist/{chunk-YGFNJBF3.mjs → chunk-DKML5425.mjs}

@@ -1,6 +1,6 @@
-import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-56HOLQKD.mjs';
+import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-RPWBYASV.mjs';
 import { ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { INTERNAL_TABLE_PREFIX } from './chunk-EUNHTFR7.mjs';
+import { INTERNAL_TABLE_PREFIX } from './chunk-JFVEGN7J.mjs';
 import { createHash } from 'crypto';
 
 var DumpOps = class {

package/dist/{chunk-NBPLGMPP.mjs → chunk-G4AG3ESO.mjs}

@@ -1,12 +1,12 @@
 import { verifyBackupRecord } from './chunk-DX4WGJL7.mjs';
-import { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces } from './chunk-C53DPOR5.mjs';
+import { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces } from './chunk-BTUD6XQO.mjs';
 import { DEFAULT_BACKUP_NAME_PREFIX, defaultStagingDir, DEFAULT_CAPTURE_INTERVAL_MS, DEFAULT_FULL_COPY_INTERVAL_MS } from './chunk-JAQ2I4OT.mjs';
 import { withLateGroupOutcomes, withLateRowCounts } from './chunk-K43WJORM.mjs';
 import { leftTransactionUnbegun, canCarryBegin, toWorkerGroupStatement, WORKER_CANCELLED_CODE, WORKER_COPY_STOPPED_CODE, deserializeError } from './chunk-75IBRE73.mjs';
 import { rowCountsOf, totalRowCounts } from './chunk-E2GRX4ZD.mjs';
-import { readCycleState, writeCycleState, removeCycleState, stagedCapturePath, captureAndCheckpointTurn } from './chunk-LRUC2GSU.mjs';
+import { readCycleState, writeCycleState, removeCycleState, stagedCapturePath, captureAndCheckpointTurn } from './chunk-UHUDPQFI.mjs';
 import { checkpointLog } from './chunk-QGVRRKB2.mjs';
-import { logPathFor } from './chunk-IWS4PJIO.mjs';
+import { logPathFor } from './chunk-AHCMO4YL.mjs';
 import { reportQuietly } from './chunk-BUWJH3D3.mjs';
 import { DEFAULT_CHAIN_NAME, readBackupChains, appendChainRecord, appendChainHead, readChainHeadAt, readChainHeads } from './chunk-CZL4D3BM.mjs';
 import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS, randomHex } from './chunk-BGJ5JVYL.mjs';

package/dist/{chunk-54MAOILS.mjs → chunk-ISDT4RBD.mjs}

@@ -1,4 +1,4 @@
-import { execute, commitFailure, asQueryError } from './chunk-LHH4PMRV.mjs';
+import { execute, commitFailure, asQueryError } from './chunk-DDIHBUEN.mjs';
 import { rowCountsOf } from './chunk-E2GRX4ZD.mjs';
 
 // src/core/group-executor.ts

package/dist/{chunk-EUNHTFR7.mjs → chunk-JFVEGN7J.mjs}

@@ -236,8 +236,8 @@ function encodeWireRowsInPlace(rows) {
     const obj = row;
     for (const k of Object.keys(obj)) {
       const cell = obj[k];
-      if (typeof cell === "bigint" || isBinaryValue(cell)) {
-        obj[k] = encodeTaggedLeaf(cell);
+      if (typeof cell === "bigint" || typeof cell === "object" && cell !== null && isBinaryValue(cell)) {
+        setOwnValue(obj, k, encodeTaggedLeaf(cell));
       }
     }
   }

package/dist/{chunk-56HOLQKD.mjs → chunk-RPWBYASV.mjs}

@@ -1,5 +1,5 @@
 import { ReplicationError, BatchValidationError } from './chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, META_TABLE, MIGRATIONS_TABLE, REPLACED_ROWS_TABLE, APPLIED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-EUNHTFR7.mjs';
+import { CHANGES_TABLE, META_TABLE, MIGRATIONS_TABLE, REPLACED_ROWS_TABLE, APPLIED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-JFVEGN7J.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/sync/hlc.ts

package/dist/{chunk-UGGWPZIP.mjs → chunk-SB3MIFLG.mjs}

@@ -1,5 +1,5 @@
-import { selectOrdinaryTableName, deleteReplacedRowsOfTable, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteAllReplacedRows, selectTableExists, ensureChangesTable, ensureReplacedRowsTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectTriggerSql, selectChangesAfterSeqSql, selectTablesChangesInRangeSql, tableInfoRows, primaryKeyColumns, tableColumnsWithGenerated, tableIndexList, indexColumns, selectTableSql, TABLE_XINFO_HIDDEN, deleteExpiredDeviceCursors, selectMinDeviceCursorBoundary, SEQ_STRING_RE, selectIndexSql } from './chunk-56HOLQKD.mjs';
-import { CDC_TRIGGER_PREFIX, CHANGES_TABLE, isReservedIdentifier, META_TABLE, encodeTaggedValues, REPLACED_ROWS_TABLE, changedAtToEventTimestamp, decodeTaggedValues, DEVICE_CURSORS_TABLE, SAFE_INT_BOUND_TEXT } from './chunk-EUNHTFR7.mjs';
+import { selectOrdinaryTableName, deleteReplacedRowsOfTable, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteAllReplacedRows, selectTableExists, ensureChangesTable, ensureReplacedRowsTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectTriggerSql, selectChangesAfterSeqSql, selectTablesChangesInRangeSql, tableInfoRows, primaryKeyColumns, tableColumnsWithGenerated, tableIndexList, indexColumns, selectTableSql, TABLE_XINFO_HIDDEN, deleteExpiredDeviceCursors, selectMinDeviceCursorBoundary, SEQ_STRING_RE, selectIndexSql } from './chunk-RPWBYASV.mjs';
+import { CDC_TRIGGER_PREFIX, CHANGES_TABLE, isReservedIdentifier, META_TABLE, encodeTaggedValues, REPLACED_ROWS_TABLE, changedAtToEventTimestamp, decodeTaggedValues, DEVICE_CURSORS_TABLE, SAFE_INT_BOUND_TEXT } from './chunk-JFVEGN7J.mjs';
 import { tokenizeSql, isKeyword } from './chunk-SEL4A4WT.mjs';
 import { synchronousPragmaValue } from './chunk-YCMB6GR4.mjs';
 import { randomHex } from './chunk-BGJ5JVYL.mjs';

package/dist/{chunk-LRUC2GSU.mjs → chunk-UHUDPQFI.mjs}

@@ -1,5 +1,5 @@
 import { checkpointLog } from './chunk-QGVRRKB2.mjs';
-import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-IWS4PJIO.mjs';
+import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-AHCMO4YL.mjs';
 import { logFrameOffset } from './chunk-BUWJH3D3.mjs';
 import { isBackupChainPosition } from './chunk-CZL4D3BM.mjs';
 import { randomHex } from './chunk-BGJ5JVYL.mjs';

package/dist/{chunk-RASMCXBN.mjs → chunk-WXPAWGTE.mjs}

@@ -158,6 +158,7 @@ var RemoteSubscriptionBuilderImpl = class {
 // src/client/database-proxy.ts
 var DEFAULT_LOAD_BATCH_SIZE = 1e3;
 var READ_CONCERN_UNSUPPORTED_MESSAGE = "This transport does not carry a per-read concern to the server. Use the HTTP transport for a per-call readConcern, or set the client-wide readConcern that topology routing applies when choosing a node.";
+var SQL_ACCEPTED = Promise.resolve();
 function closedDatabaseError() {
   return new RemoteError("TRANSPORT_ERROR", "Transport is closed");
 }
@@ -189,6 +190,7 @@ var RemoteDatabase = class {
   assertSqlAccepted() {
     const closed = this.lifetime.signal;
     if (closed.aborted) return Promise.reject(closedDatabaseError());
+    if (this.capabilities.knownToAcceptSql?.() === true) return SQL_ACCEPTED;
     return new Promise((resolve, reject) => {
       const refuse = () => reject(closedDatabaseError());
       closed.addEventListener("abort", refuse, { once: true });
@@ -525,6 +527,27 @@ function decodeTaggedValues(value) {
   }
   return out;
 }
+function decodeWireRowsInPlace(rows) {
+  if (!Array.isArray(rows)) return decodeTaggedValues(rows);
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row === null || typeof row !== "object" || Array.isArray(row)) {
+      rows[i] = decodeTaggedValues(row);
+      continue;
+    }
+    const obj = row;
+    const keys = Object.keys(obj);
+    if (keys.length === 1 && (keys[0] === BLOB_TAG || keys[0] === INT_TAG)) {
+      rows[i] = decodeTaggedValues(row);
+      continue;
+    }
+    for (const k of keys) {
+      const cell = obj[k];
+      if (cell !== null && typeof cell === "object") setOwnValue(obj, k, decodeTaggedValues(cell));
+    }
+  }
+  return rows;
+}
 function isBinaryValue(value) {
   return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
 }
@@ -629,11 +652,22 @@ var ServerCapabilities = class {
     this.requestTimeoutMs = requestTimeoutMs;
   }
   pending = null;
+  acceptsSql = false;
   lifetime = new AbortController();
   /** Cancels the capability request in flight and fails every later check with `TRANSPORT_ERROR`. */
   close() {
     this.lifetime.abort();
     this.pending = null;
+    this.acceptsSql = false;
+  }
+  /**
+   * Returns whether the report that the client last read announces SQL, which stays `false` while a report is in
+   * flight and after the client closes.
+   *
+   * @returns `true` when a statement can skip waiting on {@link ServerCapabilities.assertSqlAccepted}.
+   */
+  knownToAcceptSql() {
+    return this.acceptsSql && !this.lifetime.signal.aborted;
   }
   async read(refresh = false) {
     if (this.lifetime.signal.aborted) throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
@@ -641,9 +675,17 @@ var ServerCapabilities = class {
     if (this.pending === null) {
       const request = this.fetch();
       this.pending = request;
-      request.catch((err) => {
-        if (this.pending === request && !isMissingEndpoint(err)) this.pending = null;
-      });
+      this.acceptsSql = false;
+      request.then(
+        (report) => {
+          if (this.pending === request) this.acceptsSql = report.capabilities.includes(SQL_QUERY_CAPABILITY);
+        },
+        (err) => {
+          if (this.pending !== request) return;
+          if (isMissingEndpoint(err)) this.acceptsSql = true;
+          else this.pending = null;
+        }
+      );
     }
     return this.pending;
   }
@@ -703,7 +745,7 @@ var HttpTransport = class {
       params: encodeTaggedValues(params),
       readConcern
     });
-    return { rows: decodeTaggedValues(response.rows ?? []) };
+    return { rows: decodeWireRowsInPlace(response.rows ?? []) };
   }
   /** Sends one write. */
   async execute(sql, params) {
@@ -738,7 +780,7 @@ var HttpTransport = class {
       args: encodeTaggedValues(args),
       readConcern
     });
-    return { rows: decodeTaggedValues(response.rows ?? []) };
+    return { rows: decodeWireRowsInPlace(response.rows ?? []) };
   }
   /** Executes a registered write by name. */
   async executeNamed(name, args, writeConcern) {
@@ -1403,7 +1445,7 @@ var WebSocketTransport = class {
   async query(sql, params, readConcern) {
     await this.ensureConnected();
     const response = await this.request(queryFrame(this.nextId(), sql, params, readConcern));
-    return { rows: decodeTaggedValues(response.rows ?? []) };
+    return { rows: decodeWireRowsInPlace(response.rows ?? []) };
   }
   /** Sends one write. */
   async execute(sql, params) {
@@ -1429,7 +1471,7 @@ var WebSocketTransport = class {
   async queryNamed(name, args, readConcern) {
     await this.ensureConnected();
     const response = await this.request(namedQueryFrame(this.nextId(), name, args, readConcern));
-    return { rows: decodeTaggedValues(response.rows ?? []) };
+    return { rows: decodeWireRowsInPlace(response.rows ?? []) };
   }
   /** Executes a registered write by name. */
   async executeNamed(name, args, writeConcern) {

package/dist/client/index.d.ts

@@ -2,10 +2,10 @@ export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } f
 import { C as ConflictResolver, R as ReplicationBatch } from '../types-BG31TtrQ.js';
 export { a as ConflictContext, b as ConflictResolution } from '../types-BG31TtrQ.js';
 import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-B9CsAZp5.js';
-import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-CCY9go0g.js';
-export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-CCY9go0g.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-Doaqwrx3.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-Doaqwrx3.js';
 import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-CEJG0eFS.js';
-import { q as DeviceSyncPort, D as Database } from '../database-D4oNUy_2.js';
+import { q as DeviceSyncPort, D as Database } from '../database-fz-8CJBP.js';
 import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-5B02ixH0.js';
 import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DZSYSv0S.js';
 import '../operation-registry-CGhNT-Sn.js';

package/dist/client/index.mjs

@@ -1,5 +1,5 @@
-import { DatabaseClient, createEndpointTransport, toBaseUrl, DEFAULT_HTTP_REQUEST_TIMEOUT_MS, postJson, decodeTaggedValues, RemoteError, invokeCallerCallback, encodeTaggedValues, assertWebSocketCredentials, STAGED_STREAM_CAPABILITY, verifyDeviceSyncCapabilities, unrefTimer, toWsUrl, WebSocketTransport } from '../chunk-RASMCXBN.mjs';
-export { HttpTransport, RemoteDatabase, RemoteError, RemoteLiveQuery, RemoteSubscriptionBuilderImpl, SQL_REFUSED_MESSAGE, ServerCapabilities, WebSocketTransport } from '../chunk-RASMCXBN.mjs';
+import { DatabaseClient, createEndpointTransport, toBaseUrl, DEFAULT_HTTP_REQUEST_TIMEOUT_MS, postJson, decodeTaggedValues, RemoteError, invokeCallerCallback, encodeTaggedValues, assertWebSocketCredentials, STAGED_STREAM_CAPABILITY, verifyDeviceSyncCapabilities, unrefTimer, toWsUrl, WebSocketTransport } from '../chunk-WXPAWGTE.mjs';
+export { HttpTransport, RemoteDatabase, RemoteError, RemoteLiveQuery, RemoteSubscriptionBuilderImpl, SQL_REFUSED_MESSAGE, ServerCapabilities, WebSocketTransport } from '../chunk-WXPAWGTE.mjs';
 
 // src/core/sync/canonicalise.ts
 function canonicaliseForChecksum(value) {

package/dist/client/topology.d.ts

@@ -1,6 +1,6 @@
 import { a as ReadConcernLevel } from '../query-types-5B02ixH0.js';
 import { C as ClientOptions } from '../server-options-B9CsAZp5.js';
-import { T as Transport, D as DatabaseClient } from '../client-base-CCY9go0g.js';
+import { T as Transport, D as DatabaseClient } from '../client-base-Doaqwrx3.js';
 import { I as ClusterStatusInfo } from '../types-DTmi7pXp.js';
 import '../operation-registry-CGhNT-Sn.js';
 import '../types-BG31TtrQ.js';

package/dist/client/topology.mjs

@@ -1,4 +1,4 @@
-import { DatabaseClient, toBaseUrl, createEndpointTransport, RemoteError, toServerBaseUrl, unrefTimer } from '../chunk-RASMCXBN.mjs';
+import { DatabaseClient, toBaseUrl, createEndpointTransport, RemoteError, toServerBaseUrl, unrefTimer } from '../chunk-WXPAWGTE.mjs';
 import '../chunk-3LXXH3RA.mjs';
 
 // src/server/protocol.ts

package/dist/{client-base-CCY9go0g.d.ts → client-base-Doaqwrx3.d.ts}

@@ -21,6 +21,12 @@ interface ServerCapabilityCheck {
      * because it predates the capability report, and throws `SQL_NOT_ACCEPTED` when the report leaves SQL out.
      */
     assertSqlAccepted(): Promise<void>;
+    /**
+     * Returns `true` while the capability report that the client last read announces that the server accepts SQL, so
+     * that a remote database can send a statement without waiting on {@link ServerCapabilityCheck.assertSqlAccepted}.
+     * A check without this method makes every statement wait on that call.
+     */
+    knownToAcceptSql?(): boolean;
     /** Returns the digest of the server's operation registry, or `undefined` when the server announces none. */
     registryDigest(refresh?: boolean): Promise<string | undefined>;
     /** Cancels the capability request in flight, which the remote database calls when it closes. */
@@ -36,10 +42,18 @@ declare class ServerCapabilities implements ServerCapabilityCheck {
     private readonly headers;
     private readonly requestTimeoutMs;
     private pending;
+    private acceptsSql;
     private readonly lifetime;
     constructor(resolveUrl: () => string | Promise<string>, headers: Record<string, string> | undefined, requestTimeoutMs?: number);
     /** Cancels the capability request in flight and fails every later check with `TRANSPORT_ERROR`. */
     close(): void;
+    /**
+     * Returns whether the report that the client last read announces SQL, which stays `false` while a report is in
+     * flight and after the client closes.
+     *
+     * @returns `true` when a statement can skip waiting on {@link ServerCapabilities.assertSqlAccepted}.
+     */
+    knownToAcceptSql(): boolean;
     private read;
     registryDigest(refresh?: boolean): Promise<string | undefined>;
     assertSqlAccepted(): Promise<void>;

package/dist/core/index.d.ts

@@ -4,13 +4,13 @@ export { A as AfterQueryHook, Z as AfterQueryHookContext, _ as AppliedMigrationE
 import { B as BulkLoadDurability, a as BulkLoadResult, R as RequestContext } from '../server-options-B9CsAZp5.js';
 export { A as AppliedMigrationRow, b as AuthenticateHook, c as BulkLoadOptions, C as ClientOptions, d as ClusterStatusAuthorizer, e as CorsOptions, f as ReplicationStatusInfo, g as ServerExecutionTarget, h as ServerExecutionTargetResolver, S as ServerOptions, W as WSHandlerOptions } from '../server-options-B9CsAZp5.js';
 export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-Dpo99EI-.js';
-import { D as Database } from '../database-D4oNUy_2.js';
-export { B as BackupError, C as CDCError, b as ConnectionPool, c as ConnectionPoolError, d as ConnectionPoolOptions, e as DatabaseAlreadyExistsError, f as DatabaseBackups, g as DatabaseLifecycle, h as DatabaseNotFoundError, E as ExtensionError, F as ForbiddenSqlError, i as HookDeniedError, a as HookDispose, j as HookEvent, k as HookEventContextMap, l as HookHandler, H as HookRegistry, M as MaxDatabasesError, m as MigrationError, P as PushHookContext, Q as QueryError, R as ReadOnlyError, n as RequestDeniedError, S as SirannonError, o as SnapshotHookContext, p as SubscribeHookContext, T as TransactionError, W as WriteOverloadError } from '../database-D4oNUy_2.js';
+import { D as Database } from '../database-fz-8CJBP.js';
+export { B as BackupError, C as CDCError, b as ConnectionPool, c as ConnectionPoolError, d as ConnectionPoolOptions, e as DatabaseAlreadyExistsError, f as DatabaseBackups, g as DatabaseLifecycle, h as DatabaseNotFoundError, E as ExtensionError, F as ForbiddenSqlError, i as HookDeniedError, a as HookDispose, j as HookEvent, k as HookEventContextMap, l as HookHandler, H as HookRegistry, M as MaxDatabasesError, m as MigrationError, P as PushHookContext, Q as QueryError, R as ReadOnlyError, n as RequestDeniedError, S as SirannonError, o as SnapshotHookContext, p as SubscribeHookContext, T as TransactionError, W as WriteOverloadError } from '../database-fz-8CJBP.js';
 export { a as LiveQuery, L as LiveQueryOptions, b as LiveQueryState, c as LiveUpdate, R as ResultOp } from '../types-CEJG0eFS.js';
 import { B as BaselineFileOption } from '../baseline-Co3iIsN_.js';
 import { P as Params, E as ExecuteResult } from '../query-types-5B02ixH0.js';
 export { C as ChangeEvent, b as ChangeOperation, Q as QueryOptions, R as ReadConcern, a as ReadConcernLevel, S as Subscription, c as SubscriptionBuilder, d as SubscriptionOptions, W as WriteConcern, e as WriteConcernLevel } from '../query-types-5B02ixH0.js';
-export { S as Sirannon } from '../sirannon-B6sPKDye.js';
+export { S as Sirannon } from '../sirannon-D0CjDULa.js';
 export { D as DatabaseOperations, b as OperationArguments, O as OperationRef, a as OperationRegistry, c as OperationStatement, R as ReadOperation, W as WriteOperation, o as operationName, d as operationRef } from '../operation-registry-CGhNT-Sn.js';
 import '../types-BG31TtrQ.js';
 

package/dist/core/index.mjs

@@ -1,17 +1,17 @@
-import { Transaction, MetricsCollector, readOutcome, failedStatementOutcome, settleLateOutcome, ROW_COUNTS_UNKNOWN, leavesOutcomeUnknown, LWWResolver, REMOTE_ORIGIN_NODE_ID, BatchReader, BatchApplier, recordLocalColumnVersions, writeOutcome, batchWriteOutcome, StatementRecorder, loadPersistedHlc, isWellFormedHlc, HLC_CLOCK_META_KEY, readOneOutcome } from '../chunk-YRNLEOSU.mjs';
-export { MetricsCollector, Transaction } from '../chunk-YRNLEOSU.mjs';
+import { Transaction, MetricsCollector, readOutcome, failedStatementOutcome, settleLateOutcome, ROW_COUNTS_UNKNOWN, leavesOutcomeUnknown, LWWResolver, REMOTE_ORIGIN_NODE_ID, BatchReader, BatchApplier, recordLocalColumnVersions, writeOutcome, batchWriteOutcome, StatementRecorder, loadPersistedHlc, isWellFormedHlc, HLC_CLOCK_META_KEY, readOneOutcome } from '../chunk-AP4367HK.mjs';
+export { MetricsCollector, Transaction } from '../chunk-AP4367HK.mjs';
 import '../chunk-ZFFUVYYE.mjs';
-import { executeGroup } from '../chunk-54MAOILS.mjs';
-import { asQueryError, runInSavepoint, runWriterTransaction, withoutRowCounts, execute, executeBatchSummary, bindParams, executeBatch, queryMetered, queryForWire, queryOneMetered } from '../chunk-LHH4PMRV.mjs';
-export { execute, executeBatch, query, queryOne } from '../chunk-LHH4PMRV.mjs';
+import { executeGroup } from '../chunk-ISDT4RBD.mjs';
+import { query, queryRowsForWire, queryOne, asQueryError, runInSavepoint, runWriterTransaction, withoutRowCounts, execute, executeBatchSummary, bindParams, executeBatch, queryMetered, queryForWire, queryOneMetered } from '../chunk-DDIHBUEN.mjs';
+export { execute, executeBatch, query, queryOne } from '../chunk-DDIHBUEN.mjs';
 import { unsupported, findClauses, readSource, readSortTerms, readWindow, readSelectItems } from '../chunk-D3YF2G7X.mjs';
-import { reconcileMigrationChecksums, migrationContentChecksum, resolveDeviceRetentionPolicy, ensureCdcEpoch, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling, DEVICE_SYNC_PUSHED_SEQ_META_KEY, runBulkLoad, parseColumnDefinitions, TransactionGrouper, PrimedSubscription, dropCdcTriggers, ROWID_ALIASES } from '../chunk-UGGWPZIP.mjs';
-export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-UGGWPZIP.mjs';
+import { reconcileMigrationChecksums, migrationContentChecksum, resolveDeviceRetentionPolicy, ensureCdcEpoch, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling, DEVICE_SYNC_PUSHED_SEQ_META_KEY, runBulkLoad, parseColumnDefinitions, TransactionGrouper, PrimedSubscription, dropCdcTriggers, ROWID_ALIASES } from '../chunk-SB3MIFLG.mjs';
+export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-SB3MIFLG.mjs';
 import { planBackupRestore, backupPiecesSafeToDelete } from '../chunk-YW7IKQ7T.mjs';
 export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-YW7IKQ7T.mjs';
-import { ensureMigrationsTable, prepareUpdateMigrationChecksum, prepareInsertMigration, selectAppliedMigrationsNewestFirst, prepareDeleteMigration, selectAppliedMigrations, selectTableExists, selectMetaValue, upsertMetaValue, SEQ_STRING_RE, replaceMigrationHistory, highestMigrationVersion, selectCountOutboundChanges, ensureMetaTable, ensureChangesTable, ensureBatchApplyTables, ensureStagedPushChangesTable, PkResolver, selectMaxChangeSeq, selectMaxAppliedSourceSeq, tableColumnsWithGenerated, TABLE_XINFO_HIDDEN, selectTableSql, primaryKeyColumns, tableIndexList, upsertMetaMaxChangeSeqSql, updateChangeStampsAboveMetaSeqSql, upsertMetaValueAndMaxChangeSeqSql, insertMetaValueIfAbsent, HLC, selectMaxChangeHlc, setForeignKeysEnabled, IDENTIFIER_RE, validateDdlSafety, ensureStagedChangesTable, upsertStagedChangeSql, selectFirstStagedTransactionEnd, deleteStagedChangesUpToSeq, selectMaxStagedSeq, deleteAllStagedChanges, deleteMetaValue, selectStagedChangesInRange, assertSafeIdentifier } from '../chunk-56HOLQKD.mjs';
+import { ensureMigrationsTable, prepareUpdateMigrationChecksum, prepareInsertMigration, selectAppliedMigrationsNewestFirst, prepareDeleteMigration, selectAppliedMigrations, selectTableExists, selectMetaValue, upsertMetaValue, SEQ_STRING_RE, replaceMigrationHistory, highestMigrationVersion, selectCountOutboundChanges, ensureMetaTable, ensureChangesTable, ensureBatchApplyTables, ensureStagedPushChangesTable, PkResolver, selectMaxChangeSeq, selectMaxAppliedSourceSeq, tableColumnsWithGenerated, TABLE_XINFO_HIDDEN, selectTableSql, primaryKeyColumns, tableIndexList, upsertMetaMaxChangeSeqSql, updateChangeStampsAboveMetaSeqSql, upsertMetaValueAndMaxChangeSeqSql, insertMetaValueIfAbsent, HLC, selectMaxChangeHlc, setForeignKeysEnabled, IDENTIFIER_RE, validateDdlSafety, ensureStagedChangesTable, upsertStagedChangeSql, selectFirstStagedTransactionEnd, deleteStagedChangesUpToSeq, selectMaxStagedSeq, deleteAllStagedChanges, deleteMetaValue, selectStagedChangesInRange, assertSafeIdentifier } from '../chunk-RPWBYASV.mjs';
 import { ReplicationError } from '../chunk-BLMRNSUG.mjs';
-import { MIGRATIONS_TABLE, META_TABLE, CHANGES_TABLE, assertSqlAllowed, LIVE_PROBE_TABLE_PREFIX, eventTimestampToChangedAt, encodeTaggedValues, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues, changedAtToEventTimestamp } from '../chunk-EUNHTFR7.mjs';
+import { MIGRATIONS_TABLE, META_TABLE, CHANGES_TABLE, assertSqlAllowed, LIVE_PROBE_TABLE_PREFIX, eventTimestampToChangedAt, encodeTaggedValues, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues, changedAtToEventTimestamp } from '../chunk-JFVEGN7J.mjs';
 import { tokenizeSql, isKeyword, parameterName } from '../chunk-SEL4A4WT.mjs';
 import '../chunk-GVCNMPOS.mjs';
 import { defaultStagingDir } from '../chunk-JAQ2I4OT.mjs';
@@ -1999,6 +1999,12 @@ var DatabaseWriteController = class {
   }
   execute(sql, params, options) {
     const { observer, writeGate, writerLock, groupCommitter } = this.deps;
+    if (!observer.observesQueries) {
+      const unobserved = this.refusedCaller() ?? writeGate.run(
+        () => writerLock.isHeld() ? groupCommitter.runUngrouped(sql, params) : groupCommitter.submit(sql, params)
+      );
+      return unobserved.then(withoutRowCounts);
+    }
     const failed = {};
     return observer.withQueryHooks(
       sql,
@@ -2909,6 +2915,7 @@ var DatabaseBackups = class extends DatabaseLifecycle {
 
 // src/core/database-reads.ts
 function readRows(deps, sql, params, options) {
+  if (readsUnobserved(deps)) return query(deps.pool.acquireReader(), sql, params);
   return deps.observer.withQueryHooks(
     sql,
     params,
@@ -2917,6 +2924,7 @@ function readRows(deps, sql, params, options) {
   );
 }
 function readWireRows(deps, sql, params, options) {
+  if (readsUnobserved(deps)) return queryRowsForWire(deps.pool.acquireReader(), sql, params);
   return deps.observer.withQueryHooks(
     sql,
     params,
@@ -2925,6 +2933,7 @@ function readWireRows(deps, sql, params, options) {
   );
 }
 function readOneRow(deps, sql, params, options) {
+  if (readsUnobserved(deps)) return queryOne(deps.pool.acquireReader(), sql, params);
   return deps.observer.withQueryHooks(
     sql,
     params,
@@ -2932,6 +2941,9 @@ function readOneRow(deps, sql, params, options) {
     () => onReadConnection(deps, sql, (conn) => queryOneMetered(conn, sql, params), readOneOutcome)
   );
 }
+function readsUnobserved(deps) {
+  return deps.pool.readerCount > 0 && !deps.observer.observesQueries;
+}
 async function onReadConnection(deps, sql, op, measure) {
   const refusal = deps.pool.readerCount === 0 ? deps.writerLock.callerRefusal() : null;
   if (refusal !== null) throw refusal;
@@ -4211,10 +4223,23 @@ var Database = class _Database extends DatabaseBackups {
     this.ensureOpen();
     return readRows(this.runtime.reads, sql, params, options);
   }
-  /** @internal */
-  async queryForWire(sql, params, options) {
-    this.ensureOpen();
-    return readWireRows(this.runtime.reads, sql, params, options);
+  /**
+   * Executes a read and returns its rows encoded for a network response, which the server sends without encoding
+   * them again.
+   *
+   * @param sql - The statement to execute.
+   * @param params - The values to bind to the statement, named or positional.
+   * @param options - The read concern for this statement.
+   * @returns The rows with every value encoded for the wire.
+   * @internal
+   */
+  queryForWire(sql, params, options) {
+    try {
+      this.ensureOpen();
+      return readWireRows(this.runtime.reads, sql, params, options);
+    } catch (err) {
+      return Promise.reject(err);
+    }
   }
   /**
    * Executes a read and returns its first row.

package/dist/core/writer-worker.mjs

@@ -1,6 +1,6 @@
-import { executeGroup } from '../chunk-54MAOILS.mjs';
-import '../chunk-LHH4PMRV.mjs';
-import '../chunk-EUNHTFR7.mjs';
+import { executeGroup } from '../chunk-ISDT4RBD.mjs';
+import '../chunk-DDIHBUEN.mjs';
+import '../chunk-JFVEGN7J.mjs';
 import { WORKER_CANCELLED_CODE, serializeError, WORKER_BEGIN_FAILED_CODE, WORKER_COPY_STOPPED_CODE } from '../chunk-75IBRE73.mjs';
 import { addRowCounts, rowCountsOf, withRowCounts } from '../chunk-E2GRX4ZD.mjs';
 import { SirannonError } from '../chunk-KINDFBQP.mjs';

package/dist/{database-D4oNUy_2.d.ts → database-fz-8CJBP.d.ts}

@@ -1032,7 +1032,16 @@ declare class Database extends DatabaseBackups {
      * @returns The rows that the statement returns.
      */
     query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    /** @internal */
+    /**
+     * Executes a read and returns its rows encoded for a network response, which the server sends without encoding
+     * them again.
+     *
+     * @param sql - The statement to execute.
+     * @param params - The values to bind to the statement, named or positional.
+     * @param options - The read concern for this statement.
+     * @returns The rows with every value encoded for the wire.
+     * @internal
+     */
     queryForWire(sql: string, params?: Params, options?: QueryOptions): Promise<unknown[]>;
     /**
      * Executes a read and returns its first row.

package/dist/driver/better-sqlite3.mjs

@@ -1,15 +1,15 @@
 import { optionalDependencyError } from '../chunk-WOMADPM4.mjs';
-import { nodeResolveExtensionPath, asyncLocalWriterContext, nodeBackupEngine, nodeStreamingSupport, WriterWorker, createStatementCache, loadThroughRuntime, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-NBPLGMPP.mjs';
+import { nodeResolveExtensionPath, asyncLocalWriterContext, nodeBackupEngine, nodeStreamingSupport, WriterWorker, createStatementCache, loadThroughRuntime, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-G4AG3ESO.mjs';
 import '../chunk-DX4WGJL7.mjs';
-import '../chunk-C53DPOR5.mjs';
+import '../chunk-BTUD6XQO.mjs';
 import { defineDriver } from '../chunk-JAQ2I4OT.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-K43WJORM.mjs';
 import '../chunk-75IBRE73.mjs';
 import { withRowCounts } from '../chunk-E2GRX4ZD.mjs';
-import '../chunk-LRUC2GSU.mjs';
+import '../chunk-UHUDPQFI.mjs';
 import '../chunk-QGVRRKB2.mjs';
-import '../chunk-IWS4PJIO.mjs';
+import '../chunk-AHCMO4YL.mjs';
 import '../chunk-BUWJH3D3.mjs';
 import { synchronousPragmaValue } from '../chunk-YCMB6GR4.mjs';
 import '../chunk-CZL4D3BM.mjs';

package/dist/driver/bun.mjs

@@ -1,4 +1,4 @@
-import { defineDriver, synchronousPragmaValue, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers, SirannonError, ExtensionError } from '../chunk-N4EXO2VH.mjs';
+import { defineDriver, synchronousPragmaValue, assertHoldsStatement, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers, SirannonError, ExtensionError } from '../chunk-DBN57KVR.mjs';
 import { resolve } from 'path';
 import { AsyncLocalStorage } from 'async_hooks';
 
@@ -44,6 +44,7 @@ function bunSqlite(driverOptions) {
           db.run(sql);
         },
         async prepare(sql) {
+          assertHoldsStatement(sql);
           const stmt = db.query(sql);
           return {
             async all(...params) {

package/dist/driver/expo.mjs

@@ -1,4 +1,4 @@
-import { defineDriver, synchronousPragmaValue, ExtensionError, isNamedParams } from '../chunk-N4EXO2VH.mjs';
+import { defineDriver, synchronousPragmaValue, ExtensionError, assertHoldsStatement, isNamedParams } from '../chunk-DBN57KVR.mjs';
 
 // src/drivers/expo/bind.ts
 var LARGEST_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
@@ -49,6 +49,7 @@ function expoSqlite() {
           await dbHandle.execAsync(sql);
         },
         async prepare(sql) {
+          assertHoldsStatement(sql);
           return {
             async all(...params) {
               return dbHandle.getAllAsync(sql, expoBindParams(params));

package/dist/driver/node.mjs

@@ -1,14 +1,14 @@
-import { nodeResolveExtensionPath, asyncLocalWriterContext, createStatementCache, nodeBackupEngine, nodeStreamingSupport, WriterWorker, loadThroughRuntime, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-NBPLGMPP.mjs';
+import { nodeResolveExtensionPath, asyncLocalWriterContext, createStatementCache, nodeBackupEngine, nodeStreamingSupport, WriterWorker, loadThroughRuntime, bindableParams, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-G4AG3ESO.mjs';
 import '../chunk-DX4WGJL7.mjs';
-import '../chunk-C53DPOR5.mjs';
+import '../chunk-BTUD6XQO.mjs';
 import { defineDriver } from '../chunk-JAQ2I4OT.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-K43WJORM.mjs';
 import '../chunk-75IBRE73.mjs';
 import '../chunk-E2GRX4ZD.mjs';
-import '../chunk-LRUC2GSU.mjs';
+import '../chunk-UHUDPQFI.mjs';
 import '../chunk-QGVRRKB2.mjs';
-import '../chunk-IWS4PJIO.mjs';
+import '../chunk-AHCMO4YL.mjs';
 import '../chunk-BUWJH3D3.mjs';
 import { synchronousPragmaValue } from '../chunk-YCMB6GR4.mjs';
 import '../chunk-CZL4D3BM.mjs';
@@ -37,6 +37,68 @@ async function copyDatabaseWithNodeSqlite(db, request) {
   return final;
 }
 
+// src/core/driver/statement-text.ts
+var SPACE = 32;
+var TAB = 9;
+var LINE_FEED = 10;
+var VERTICAL_TAB = 11;
+var FORM_FEED = 12;
+var CARRIAGE_RETURN = 13;
+var SEMICOLON = 59;
+var HYPHEN = 45;
+var SLASH = 47;
+var ASTERISK = 42;
+var NO_STATEMENT_MESSAGE = "The supplied SQL string contains no statements";
+function startsSqliteSpace(code) {
+  return code === SPACE || code === TAB || code === LINE_FEED || code === FORM_FEED || code === CARRIAGE_RETURN;
+}
+function continuesSqliteSpace(code) {
+  return startsSqliteSpace(code) || code === VERTICAL_TAB;
+}
+function holdsNoStatement(sql) {
+  const firstNul = sql.indexOf("\0");
+  const text = firstNul === -1 ? sql : sql.slice(0, firstNul);
+  let index = 0;
+  while (index < text.length) {
+    const code = text.charCodeAt(index);
+    if (startsSqliteSpace(code)) {
+      index++;
+      while (index < text.length && continuesSqliteSpace(text.charCodeAt(index))) index++;
+      continue;
+    }
+    if (code === SEMICOLON) {
+      index++;
+      continue;
+    }
+    const next = text.charCodeAt(index + 1);
+    if (code === HYPHEN && next === HYPHEN) {
+      const lineEnd = text.indexOf("\n", index + 2);
+      if (lineEnd === -1) return true;
+      index = lineEnd;
+      continue;
+    }
+    if (code === SLASH && next === ASTERISK && index + 2 < text.length) {
+      const commentEnd = text.indexOf("*/", index + 2);
+      if (commentEnd === -1) return true;
+      index = commentEnd + 2;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function assertHoldsStatement(sql) {
+  if (holdsNoStatement(sql)) throw new RangeError(NO_STATEMENT_MESSAGE);
+}
+
+// src/drivers/node/statement-text.ts
+function prepareStatement(db, sql) {
+  assertHoldsStatement(sql);
+  const statement = db.prepare(sql);
+  statement.setReadBigInts(true);
+  return statement;
+}
+
 // src/drivers/node/index.ts
 var FIRST_NODE_MAJOR_THAT_OPENS_A_COPY_BY_URI = 23;
 function parsesBackupUris() {
@@ -83,18 +145,13 @@ function nodeSqlite(driverOptions) {
       if (options?.walAutoCheckpoint !== void 0) {
         db.exec(`PRAGMA wal_autocheckpoint = ${Math.trunc(options.walAutoCheckpoint)}`);
       }
-      const batchStatementFor = createStatementCache((sql) => {
-        const stmt = db.prepare(sql);
-        stmt.setReadBigInts(true);
-        return stmt;
-      });
+      const batchStatementFor = createStatementCache((sql) => prepareStatement(db, sql));
       const conn = {
         async exec(sql) {
           db.exec(sql);
         },
         async prepare(sql) {
-          const stmt = db.prepare(sql);
-          stmt.setReadBigInts(true);
+          const stmt = prepareStatement(db, sql);
           return {
             async all(...params) {
               return narrowRowsIntegers(stmt.all(...bindableParams(params)));

package/dist/driver/wa-sqlite.mjs

@@ -35,6 +35,60 @@ function defineDriver(config) {
   });
 }
 
+// src/core/driver/statement-text.ts
+var SPACE = 32;
+var TAB = 9;
+var LINE_FEED = 10;
+var VERTICAL_TAB = 11;
+var FORM_FEED = 12;
+var CARRIAGE_RETURN = 13;
+var SEMICOLON = 59;
+var HYPHEN = 45;
+var SLASH = 47;
+var ASTERISK = 42;
+var NO_STATEMENT_MESSAGE = "The supplied SQL string contains no statements";
+function startsSqliteSpace(code) {
+  return code === SPACE || code === TAB || code === LINE_FEED || code === FORM_FEED || code === CARRIAGE_RETURN;
+}
+function continuesSqliteSpace(code) {
+  return startsSqliteSpace(code) || code === VERTICAL_TAB;
+}
+function holdsNoStatement(sql) {
+  const firstNul = sql.indexOf("\0");
+  const text = firstNul === -1 ? sql : sql.slice(0, firstNul);
+  let index = 0;
+  while (index < text.length) {
+    const code = text.charCodeAt(index);
+    if (startsSqliteSpace(code)) {
+      index++;
+      while (index < text.length && continuesSqliteSpace(text.charCodeAt(index))) index++;
+      continue;
+    }
+    if (code === SEMICOLON) {
+      index++;
+      continue;
+    }
+    const next = text.charCodeAt(index + 1);
+    if (code === HYPHEN && next === HYPHEN) {
+      const lineEnd = text.indexOf("\n", index + 2);
+      if (lineEnd === -1) return true;
+      index = lineEnd;
+      continue;
+    }
+    if (code === SLASH && next === ASTERISK && index + 2 < text.length) {
+      const commentEnd = text.indexOf("*/", index + 2);
+      if (commentEnd === -1) return true;
+      index = commentEnd + 2;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function assertHoldsStatement(sql) {
+  if (holdsNoStatement(sql)) throw new RangeError(NO_STATEMENT_MESSAGE);
+}
+
 // src/core/driver/synchronous.ts
 var DEFAULT_SYNCHRONOUS = "normal";
 var SYNCHRONOUS_PRAGMA_VALUES = {
@@ -273,6 +327,7 @@ function waSqlite(driverOptions) {
           await sqlite3.exec(db, sql);
         },
         async prepare(sql) {
+          assertHoldsStatement(sql);
           return {
             async all(...params) {
               const result = await execStatements(sql, params);

package/dist/replication/index.d.ts

@@ -1,5 +1,5 @@
 export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-BnNAEjwB.js';
-import { r as HLC, D as Database, S as SirannonError } from '../database-D4oNUy_2.js';
+import { r as HLC, D as Database, S as SirannonError } from '../database-fz-8CJBP.js';
 import { J as SQLiteConnection, s as BackupGroupSource, a4 as ClusterReadEndpointInfo, I as ClusterStatusInfo, T as Transaction } from '../types-DTmi7pXp.js';
 import { C as ClusterCoordinator, c as CoordinatorWatchDisposer, o as CoordinatorLease, e as ReplicationGroupState } from '../types-MczwKtul.js';
 export { A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, l as AdmitNodeToInSyncSetInput, j as CompareAndAdvancePrimaryTermInput, k as CompareAndAdvancePrimaryTermResult, b as ControllerLeaseWatcher, n as CoordinatorCompatibilityMetadata, d as CoordinatorNodeSession, p as CoordinatorPrimary, N as NodeSessionWatcher, P as PromoteEligibleReplicaInput, R as RegisterNodeSessionInput, i as ReplicationGroupWatcher, S as SetReplicationGroupStateInput, U as UpdateInSyncSetInput, m as UpdateNodeMaintenanceInput } from '../types-MczwKtul.js';

package/dist/replication/index.mjs

@@ -1,16 +1,16 @@
 import { groupMemberIds, isGroupMember, sameNodeIdSet, compatibilityAllowsPromotion, arraysEqual } from '../chunk-PJRCMG7L.mjs';
 import { CoordinatorError, TopologyError, WriteConcernError, AuthorityError, SyncError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError } from '../chunk-KU32OT4H.mjs';
 export { AuthorityError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-KU32OT4H.mjs';
-import { LWWResolver, BatchReader, BatchApplier, StampOps, writeOutcome, failedStatementOutcome, StatementRecorder, batchWriteOutcome, isWellFormedHlc, Transaction, loadPersistedHlc } from '../chunk-YRNLEOSU.mjs';
-export { LWWResolver } from '../chunk-YRNLEOSU.mjs';
+import { LWWResolver, BatchReader, BatchApplier, StampOps, writeOutcome, failedStatementOutcome, StatementRecorder, batchWriteOutcome, isWellFormedHlc, Transaction, loadPersistedHlc } from '../chunk-AP4367HK.mjs';
+export { LWWResolver } from '../chunk-AP4367HK.mjs';
 import '../chunk-ZFFUVYYE.mjs';
-import { runWriterTransaction, execute, withoutRowCounts } from '../chunk-LHH4PMRV.mjs';
-import { DumpOps, dumpSchema, tablesInFkOrder } from '../chunk-YGFNJBF3.mjs';
-import { canonicaliseForChecksum, HLC, PkResolver, selectMaxChangeHlc, selectMaxColumnVersionHlc, selectMaxAppliedSourceSeq, upsertPeerAckedSeq, selectPeerAckedSeq, selectMaxChangeSeq, selectMaxNodeChangeSeq, selectMinPeerAckedSeq, upsertSyncTableStatus, upsertSyncMeta, selectSyncMetaRow, selectCompletedSyncTableNames, ensureChangesTable, ensureReplicationStateTables, ensureMetaTable, IDENTIFIER_RE, setForeignKeysEnabled, deleteSyncTableStates, extractDroppedTable, insertDdlChange, validateDdlSafety, prepareInsertAppliedChange, selectNewestHistoryChange, upsertQuarantined, deleteStampedChangesUpToSeq, deleteColumnVersions, upsertHistoryBase, deleteAppliedChangesAfterSeq, deletePeerState, upsertAnchoredTerm, selectPrimaryTermStart, selectMaxHistoryChangeSeq, deletePeerStates, upsertPrimaryTermStart, selectHistoryTransaction, selectMaxAppliedSourceSeqByNode, selectAnchoredTerm, selectQuarantined, selectHistoryBase, selectHistoryChangesAfterHlc, deleteHistoryChangesAfterHlc, deleteColumnVersionsAfterHlc, tablePkColumns, deletePrimaryTermStart, selectMaxAssignedChangeSeq } from '../chunk-56HOLQKD.mjs';
-export { HLC } from '../chunk-56HOLQKD.mjs';
+import { runWriterTransaction, execute, withoutRowCounts } from '../chunk-DDIHBUEN.mjs';
+import { DumpOps, dumpSchema, tablesInFkOrder } from '../chunk-DKML5425.mjs';
+import { canonicaliseForChecksum, HLC, PkResolver, selectMaxChangeHlc, selectMaxColumnVersionHlc, selectMaxAppliedSourceSeq, upsertPeerAckedSeq, selectPeerAckedSeq, selectMaxChangeSeq, selectMaxNodeChangeSeq, selectMinPeerAckedSeq, upsertSyncTableStatus, upsertSyncMeta, selectSyncMetaRow, selectCompletedSyncTableNames, ensureChangesTable, ensureReplicationStateTables, ensureMetaTable, IDENTIFIER_RE, setForeignKeysEnabled, deleteSyncTableStates, extractDroppedTable, insertDdlChange, validateDdlSafety, prepareInsertAppliedChange, selectNewestHistoryChange, upsertQuarantined, deleteStampedChangesUpToSeq, deleteColumnVersions, upsertHistoryBase, deleteAppliedChangesAfterSeq, deletePeerState, upsertAnchoredTerm, selectPrimaryTermStart, selectMaxHistoryChangeSeq, deletePeerStates, upsertPrimaryTermStart, selectHistoryTransaction, selectMaxAppliedSourceSeqByNode, selectAnchoredTerm, selectQuarantined, selectHistoryBase, selectHistoryChangesAfterHlc, deleteHistoryChangesAfterHlc, deleteColumnVersionsAfterHlc, tablePkColumns, deletePrimaryTermStart, selectMaxAssignedChangeSeq } from '../chunk-RPWBYASV.mjs';
+export { HLC } from '../chunk-RPWBYASV.mjs';
 import { ReplicationError, BatchValidationError } from '../chunk-BLMRNSUG.mjs';
 export { BatchValidationError, ConflictError, ReplicationError } from '../chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues } from '../chunk-EUNHTFR7.mjs';
+import { CHANGES_TABLE, INTERNAL_TABLE_PREFIX, isReservedIdentifier, decodeTaggedValues } from '../chunk-JFVEGN7J.mjs';
 import '../chunk-GVCNMPOS.mjs';
 import '../chunk-K43WJORM.mjs';
 import { rowCountsOf } from '../chunk-E2GRX4ZD.mjs';

package/dist/server/index.d.ts

@@ -2,10 +2,10 @@ import { h as BackupChain, l as BackupChainRecord, p as BackupCycleStatus, C as
 import { b as BackupRestoreProgress, a as BackupRestoreReport } from '../restore-options-CcMukOLO.js';
 import { a as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DZSYSv0S.js';
 export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-DZSYSv0S.js';
-import { S as Sirannon } from '../sirannon-B6sPKDye.js';
+import { S as Sirannon } from '../sirannon-D0CjDULa.js';
 import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-B9CsAZp5.js';
 import { W as WriteConcern, R as ReadConcern } from '../query-types-5B02ixH0.js';
-import '../database-D4oNUy_2.js';
+import '../database-fz-8CJBP.js';
 import '../change-tracker-Dpo99EI-.js';
 import '../database-backup-BwTNiBm2.js';
 import '../types-BG31TtrQ.js';

package/dist/server/index.mjs

@@ -1,17 +1,17 @@
 import { restoreBackup, MAX_RESTORE_BATCH_SIZE } from '../chunk-L6EX6K27.mjs';
-import { tablesInFkOrder, dumpSchema, dumpTablePages } from '../chunk-YGFNJBF3.mjs';
-import { resolveDeviceRetentionPolicy, ChangeTracker, SubscriptionManager, ensureCdcEpoch, migrationChecksum, applyDeviceCursorBoundary, needsResync, filteredChange, TransactionGrouper, isBulkLoadDurability, PrimedSubscription } from '../chunk-UGGWPZIP.mjs';
+import { tablesInFkOrder, dumpSchema, dumpTablePages } from '../chunk-DKML5425.mjs';
+import { resolveDeviceRetentionPolicy, ChangeTracker, SubscriptionManager, ensureCdcEpoch, migrationChecksum, applyDeviceCursorBoundary, needsResync, filteredChange, TransactionGrouper, isBulkLoadDurability, PrimedSubscription } from '../chunk-SB3MIFLG.mjs';
 import '../chunk-YW7IKQ7T.mjs';
-import { SEQ_STRING_RE, highestMigrationVersion, selectCountTableRows, selectTableExists, selectAppliedMigrations, PkResolver, ensureDeviceCursorsTable, upsertDeviceCursor, updateDeviceCursor, selectMaxAssignedChangeSeq, MAX_CHANGE_SEQ, HLC, selectMaxChangeSeq, canonicaliseForChecksum, selectDeviceCursorExists, IDENTIFIER_RE } from '../chunk-56HOLQKD.mjs';
+import { SEQ_STRING_RE, highestMigrationVersion, selectCountTableRows, selectTableExists, selectAppliedMigrations, PkResolver, ensureDeviceCursorsTable, upsertDeviceCursor, updateDeviceCursor, selectMaxAssignedChangeSeq, MAX_CHANGE_SEQ, HLC, selectMaxChangeSeq, canonicaliseForChecksum, selectDeviceCursorExists, IDENTIFIER_RE } from '../chunk-RPWBYASV.mjs';
 import { BatchValidationError } from '../chunk-BLMRNSUG.mjs';
-import { MIGRATIONS_TABLE, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, DEVICE_CURSORS_TABLE, CHANGES_TABLE, INTERNAL_TABLE_PREFIX } from '../chunk-EUNHTFR7.mjs';
+import { MIGRATIONS_TABLE, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, DEVICE_CURSORS_TABLE, CHANGES_TABLE, INTERNAL_TABLE_PREFIX } from '../chunk-JFVEGN7J.mjs';
 import { createOperationSource, operationRegistryDigest, findRead, isRefusal, resolveArguments, findWrite } from '../chunk-KB4OLJAD.mjs';
 import '../chunk-SEL4A4WT.mjs';
 import '../chunk-GVCNMPOS.mjs';
 import { optionalDependencyError } from '../chunk-WOMADPM4.mjs';
-import { discardStagedChain } from '../chunk-LRUC2GSU.mjs';
+import { discardStagedChain } from '../chunk-UHUDPQFI.mjs';
 import '../chunk-QGVRRKB2.mjs';
-import '../chunk-IWS4PJIO.mjs';
+import '../chunk-AHCMO4YL.mjs';
 import '../chunk-BUWJH3D3.mjs';
 import '../chunk-YCMB6GR4.mjs';
 import '../chunk-CZL4D3BM.mjs';
@@ -648,10 +648,13 @@ function writeCorsOrigin(res, cors, requestOrigin) {
 }
 
 // src/server/wire-rows.ts
-async function queryWireRows(target, sql, params, options) {
+function queryWireRows(target, sql, params, options) {
   if (target.queryForWire) {
     return target.queryForWire(sql, params, options);
   }
+  return queryAndEncode(target, sql, params, options);
+}
+async function queryAndEncode(target, sql, params, options) {
   return encodeTaggedValues(await target.query(sql, params, options));
 }
 
@@ -1994,6 +1997,10 @@ var DEFAULT_WS_BACKPRESSURE_BYTES = 16 * 1048576;
 var UWS_MAX_LIMIT_BYTES = 4294967295;
 var DEFAULT_CLOSE_TIMEOUT_MS = DEFAULT_HTTP_REQUEST_TIMEOUT_MS;
 var MAX_TIMER_DELAY_MS = 2147483647;
+var MAX_UTF8_BYTES_PER_UTF16_UNIT = 3;
+function exceedsUtf8Bytes(text, maxBytes) {
+  return text.length * MAX_UTF8_BYTES_PER_UTF16_UNIT > maxBytes && Buffer.byteLength(text) > maxBytes;
+}
 function resolveCloseTimeout(value) {
   if (value === void 0) return DEFAULT_CLOSE_TIMEOUT_MS;
   if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > MAX_TIMER_DELAY_MS) {
@@ -3687,7 +3694,7 @@ var WSHandler = class {
   handleMessage(conn, data) {
     const state = this.connections.get(conn);
     if (!state) return;
-    if (Buffer.byteLength(data) > this.maxPayloadLength) {
+    if (exceedsUtf8Bytes(data, this.maxPayloadLength)) {
       conn.close(WS_CLOSE_MESSAGE_TOO_BIG, "PAYLOAD_TOO_LARGE");
       return;
     }
@@ -3800,12 +3807,13 @@ var WSHandler = class {
     await this.cdc.closeAll();
   }
   operationContext(conn, state) {
-    return {
+    state.operationContext ??= {
       target: state.executionTarget,
       sendResult: (id, data) => this.frames.send(conn, { type: "result", id, data }),
       sendError: (id, code, message) => this.frames.sendError(conn, id, code, message),
       sendCaughtError: (id, err) => this.frames.sendSirannonError(conn, id, err)
     };
+    return state.operationContext;
   }
   namedContext(conn, state) {
     return {

package/dist/{sirannon-B6sPKDye.d.ts → sirannon-D0CjDULa.d.ts}

@@ -1,4 +1,4 @@
-import { H as HookRegistry, D as Database, a as HookDispose } from './database-D4oNUy_2.js';
+import { H as HookRegistry, D as Database, a as HookDispose } from './database-fz-8CJBP.js';
 import { a as SirannonOptions, S as SQLiteDriver, b as MetricsCollector, D as DatabaseOptions, M as Migration, c as BeforeQueryHook, A as AfterQueryHook, d as BeforeConnectHook, e as DatabaseOpenHook, f as DatabaseCloseHook } from './types-DTmi7pXp.js';
 
 /** The outcome of taking one database offline.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.3.5-next.71",
+  "version": "0.3.5-next.72",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",
@@ -149,7 +149,7 @@
   },
   "peerDependencies": {
     "@bufbuild/protobuf": ">=2.0.0",
-    "@delali/sirannon-sqlite": "0.3.5-next.71",
+    "@delali/sirannon-sqlite": "0.3.5-next.72",
     "@grpc/grpc-js": ">=1.10.0",
     "better-sqlite3": ">=12.0.0",
     "etcd3": ">=1.1.2",
@@ -193,7 +193,7 @@
   },
   "devDependencies": {
     "@bufbuild/protobuf": "2.11.0",
-    "@delali/sirannon-sqlite": "0.3.5-next.71",
+    "@delali/sirannon-sqlite": "0.3.5-next.72",
     "@grpc/grpc-js": "1.14.4",
     "@microsoft/api-extractor": "7.58.12",
     "@types/better-sqlite3": "7.6.13",
@@ -221,11 +221,11 @@
     "vitest": "4.0.18"
   },
   "optionalDependencies": {
-    "@delali/sirannon-vfs-darwin-arm64": "0.3.5-next.71",
-    "@delali/sirannon-vfs-darwin-x64": "0.3.5-next.71",
-    "@delali/sirannon-vfs-linux-arm64": "0.3.5-next.71",
-    "@delali/sirannon-vfs-linux-x64": "0.3.5-next.71",
-    "@delali/sirannon-vfs-win32-arm64": "0.3.5-next.71",
-    "@delali/sirannon-vfs-win32-x64": "0.3.5-next.71"
+    "@delali/sirannon-vfs-darwin-arm64": "0.3.5-next.72",
+    "@delali/sirannon-vfs-darwin-x64": "0.3.5-next.72",
+    "@delali/sirannon-vfs-linux-arm64": "0.3.5-next.72",
+    "@delali/sirannon-vfs-linux-x64": "0.3.5-next.72",
+    "@delali/sirannon-vfs-win32-arm64": "0.3.5-next.72",
+    "@delali/sirannon-vfs-win32-x64": "0.3.5-next.72"
   }
 }