@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/{chunk-MYNI2WFS.mjs → chunk-52XW3Z76.mjs}

@@ -1,5 +1,25 @@
-import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-6CMCO7S4.mjs';
-import { SirannonError, QueryError } from './chunk-PBRXXISQ.mjs';
+import { assertSqlAllowed, encodeWireRowsInPlace } from './chunk-2O3PP4CF.mjs';
+import { SirannonError, TransactionError, QueryError } from './chunk-KINDFBQP.mjs';
+
+// src/core/writer-transaction.ts
+function commitFailure(err) {
+  if (err instanceof SirannonError) return err;
+  const reason = err instanceof Error ? err.message : String(err);
+  return new TransactionError(`SQLite could not commit the transaction: ${reason}`, err);
+}
+async function runWriterTransaction(conn, body) {
+  let bodyFinished = false;
+  try {
+    return await conn.transaction(async (txConn) => {
+      const value = await body(txConn);
+      bodyFinished = true;
+      return value;
+    });
+  } catch (err) {
+    if (!bodyFinished) throw err;
+    throw commitFailure(err);
+  }
+}
 
 // src/core/query-executor.ts
 var STATEMENT_CACHE_CAPACITY = 128;
@@ -97,8 +117,7 @@ async function executeGroup(conn, units) {
   }
   const failure = await execControl(conn, "COMMIT");
   if (!failure) return outcomes;
-  await rollbackQuietly(conn);
-  return outcomes.map(() => ({ ok: false, error: failure }));
+  return settleRefusedCommit(conn, units, outcomes, failure);
 }
 async function runUnit(conn, unit) {
   const values = new Array(unit.statements.length);
@@ -109,7 +128,7 @@ async function runUnit(conn, unit) {
   return values;
 }
 function controlError(err, sql) {
-  return asQueryError(err, sql);
+  return sql === "COMMIT" ? commitFailure(err) : asQueryError(err, sql);
 }
 async function execControl(conn, sql) {
   try {
@@ -135,8 +154,21 @@ async function executeGroupIsolated(conn, units) {
   }
   const failure = await execControl(conn, "COMMIT");
   if (!failure) return outcomes;
-  await rollbackQuietly(conn);
-  return outcomes.map((outcome) => outcome.ok ? { ok: false, error: failure } : outcome);
+  return settleRefusedCommit(conn, units, outcomes, failure);
+}
+async function settleRefusedCommit(conn, units, outcomes, failure) {
+  const transactionStillOpen = await execControl(conn, "ROLLBACK") === null;
+  const rerunEachAlone = transactionStillOpen && succeededUnitCount(outcomes) > 1;
+  for (let i = 0; i < units.length; i++) {
+    if (!outcomes[i].ok) continue;
+    outcomes[i] = rerunEachAlone ? await runUnitAlone(conn, units[i]) : { ok: false, error: failure };
+  }
+  return outcomes;
+}
+function succeededUnitCount(outcomes) {
+  let count = 0;
+  for (const outcome of outcomes) if (outcome.ok) count++;
+  return count;
 }
 async function runIsolatedUnit(conn, unit, savepoint) {
   const notOpened = await execControl(conn, `SAVEPOINT ${savepoint}`);
@@ -221,4 +253,4 @@ async function executeBatchSummary(conn, sql, paramsBatch) {
   return { rowsLoaded: paramsBatch.length, changes };
 }
 
-export { bindParams, execute, executeBatch, executeBatchSummary, executeGroup, query, queryForWire, queryOne };
+export { bindParams, execute, executeBatch, executeBatchSummary, executeGroup, query, queryForWire, queryOne, runWriterTransaction };

package/dist/chunk-55YRLSM2.mjs

@@ -0,0 +1,57 @@
+// src/transport/grpc/client-reconnect.ts
+var RECONNECT_MIN_DELAY_MS = 250;
+var RECONNECT_MAX_DELAY_MS = 5e3;
+var stateByTransport = /* @__PURE__ */ new WeakMap();
+function stateFor(transport) {
+  const existing = stateByTransport.get(transport);
+  if (existing) return existing;
+  const created = { timers: /* @__PURE__ */ new Map(), delays: /* @__PURE__ */ new Map(), dialled: /* @__PURE__ */ new Map() };
+  stateByTransport.set(transport, created);
+  return created;
+}
+function claimEndpoint(transport, endpoint) {
+  const state = stateFor(transport);
+  if (state.dialled.has(endpoint)) return false;
+  state.dialled.set(endpoint, () => void 0);
+  return true;
+}
+function registerEndpointAbort(transport, endpoint, abort) {
+  const state = stateFor(transport);
+  if (!state.dialled.has(endpoint)) return;
+  state.dialled.set(endpoint, abort);
+}
+function releaseEndpoint(transport, endpoint) {
+  stateFor(transport).dialled.delete(endpoint);
+}
+function noteEndpointReachable(transport, endpoint) {
+  stateFor(transport).delays.delete(endpoint);
+}
+function scheduleEndpointRedial(transport, endpoint, redial) {
+  if (!transport.connected) return;
+  const state = stateFor(transport);
+  if (state.timers.has(endpoint)) return;
+  const delayMs = state.delays.get(endpoint) ?? RECONNECT_MIN_DELAY_MS;
+  state.delays.set(endpoint, Math.min(delayMs * 2, RECONNECT_MAX_DELAY_MS));
+  const timer = setTimeout(() => {
+    state.timers.delete(endpoint);
+    if (!transport.connected) return;
+    redial();
+  }, delayMs);
+  state.timers.set(endpoint, timer);
+}
+function stopEndpointDialling(transport) {
+  const state = stateByTransport.get(transport);
+  if (!state) return;
+  for (const timer of state.timers.values()) {
+    clearTimeout(timer);
+  }
+  state.timers.clear();
+  state.delays.clear();
+  const aborts = [...state.dialled.values()];
+  state.dialled.clear();
+  for (const abort of aborts) {
+    abort();
+  }
+}
+
+export { claimEndpoint, noteEndpointReachable, registerEndpointAbort, releaseEndpoint, scheduleEndpointRedial, stopEndpointDialling };

package/dist/{chunk-KDAHYFW7.mjs → chunk-6AOJCNRU.mjs}

@@ -1,9 +1,9 @@
-import { checkpointLog } from './chunk-U445A3C4.mjs';
-import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-E6IMX7RS.mjs';
-import { logFrameOffset } from './chunk-GYCEJNU4.mjs';
-import { isBackupChainPosition } from './chunk-YVF2ZJTE.mjs';
+import { checkpointLog } from './chunk-QGVRRKB2.mjs';
+import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-KJLNYOOL.mjs';
+import { logFrameOffset } from './chunk-R7GBXNTO.mjs';
+import { isBackupChainPosition } from './chunk-CZL4D3BM.mjs';
 import { randomHex } from './chunk-QBBLSQHQ.mjs';
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 import { readFile, mkdir, writeFile, rename, rm, readdir } from 'fs/promises';
 import { dirname, join } from 'path';
 

package/dist/{chunk-KXTYR2OQ.mjs → chunk-A3PHCO6W.mjs}

@@ -1,7 +1,7 @@
-import { query, execute, executeBatch } from './chunk-MYNI2WFS.mjs';
-import { ensureMetaTable, selectMetaValue, IDENTIFIER_RE, selectAppliedSourceSeqsInRange, prepareInsertAppliedChange, validateDdlSafety, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareDeleteRowColumnVersionsUpToHlc, canonicaliseForChecksum, prepareUpsertNewerColumnVersion, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion } from './chunk-45MKELYA.mjs';
-import { ReplicationError, BatchValidationError } from './chunk-2QLXDHAP.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues } from './chunk-6CMCO7S4.mjs';
+import { query, execute, executeBatch, runWriterTransaction } from './chunk-52XW3Z76.mjs';
+import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, selectAppliedSourceSeqsInRange, prepareInsertAppliedChange, validateDdlSafety, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareDeleteRowColumnVersionsUpToHlc, canonicaliseForChecksum, prepareUpsertNewerColumnVersion, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion } from './chunk-ESTZZPT5.mjs';
+import { BatchValidationError, ConflictError } from './chunk-BLMRNSUG.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues } from './chunk-2O3PP4CF.mjs';
 import { sha256Hex } from './chunk-GVCNMPOS.mjs';
 
 // src/core/transaction.ts
@@ -11,21 +11,21 @@ var Transaction = class _Transaction {
   }
   _lastInsertRowId = 0;
   /**
-   * Runs a read inside this transaction.
+   * Executes a read inside this transaction.
    *
-   * @param sql - The statement to run.
-   * @param params - Values bound to the statement, named or positional.
-   * @returns The rows the statement produced.
+   * @param sql - The statement to execute.
+   * @param params - The values to bind to the statement, named or positional.
+   * @returns The rows that the statement returns.
    */
   async query(sql, params) {
     return query(this.conn, sql, params);
   }
   /**
-   * Runs one write inside this transaction.
+   * Executes one write inside this transaction.
    *
-   * @param sql - The statement to run.
-   * @param params - Values bound to the statement, named or positional.
-   * @returns How many rows changed, and the last inserted row id.
+   * @param sql - The statement to execute.
+   * @param params - The values to bind to the statement, named or positional.
+   * @returns The number of rows that the statement changed, and the row id of the last inserted row.
    */
   async execute(sql, params) {
     const result = await execute(this.conn, sql, params);
@@ -33,10 +33,10 @@ var Transaction = class _Transaction {
     return result;
   }
   /**
-   * Runs one statement over many parameter sets inside this transaction.
+   * Executes one statement once for each parameter set, inside this transaction.
    *
-   * @param sql - The statement to run for each parameter set.
-   * @param paramsBatch - One parameter set per run.
+   * @param sql - The statement to execute for each parameter set.
+   * @param paramsBatch - One parameter set for each execution.
    * @returns One result per parameter set, in order.
    */
   async executeBatch(sql, paramsBatch) {
@@ -47,110 +47,24 @@ var Transaction = class _Transaction {
     return results;
   }
   /**
-   * Row id SQLite assigned to the last row this transaction inserted.
+   * The row id that SQLite assigned to the last row that this transaction inserted.
    */
   get lastInsertRowId() {
     return this._lastInsertRowId;
   }
   /** @internal */
   static async run(conn, fn) {
-    return conn.transaction(async (txConn) => {
+    return runWriterTransaction(conn, async (txConn) => {
       const tx = new _Transaction(txConn);
       return fn(tx);
     });
   }
 };
 
-// src/core/sync/hlc.ts
-var MAX_LOGICAL = 65535;
-var HLC = class _HLC {
-  wallMs;
-  logical;
-  nodeId;
-  constructor(nodeId) {
-    this.nodeId = nodeId;
-    this.wallMs = 0;
-    this.logical = 0;
-  }
-  /**
-   * Generate a new HLC timestamp, advancing the clock.
-   *
-   * @internal
-   */
-  now() {
-    const physicalMs = Date.now();
-    if (physicalMs > this.wallMs) {
-      this.wallMs = physicalMs;
-      this.logical = 0;
-    } else {
-      this.logical += 1;
-      if (this.logical > MAX_LOGICAL) {
-        throw new ReplicationError("HLC logical counter overflow");
-      }
-    }
-    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
-  }
-  /**
-   * Merge a remote HLC timestamp into the local clock and return the updated value.
-   *
-   * @internal
-   */
-  receive(remote) {
-    const r = _HLC.decode(remote);
-    const physicalMs = Date.now();
-    if (physicalMs > this.wallMs && physicalMs > r.wallMs) {
-      this.wallMs = physicalMs;
-      this.logical = 0;
-    } else if (r.wallMs > this.wallMs) {
-      this.wallMs = r.wallMs;
-      this.logical = r.logical + 1;
-    } else if (this.wallMs > r.wallMs) {
-      this.logical += 1;
-    } else {
-      this.logical = Math.max(this.logical, r.logical) + 1;
-    }
-    if (this.logical > MAX_LOGICAL) {
-      throw new ReplicationError("HLC logical counter overflow");
-    }
-    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
-  }
-  /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
-  static compare(a, b) {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  }
-  /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
-  static decode(hlc) {
-    const parts = hlc.split("-");
-    if (parts.length < 3) {
-      throw new ReplicationError(`Invalid HLC format: ${hlc}`);
-    }
-    return {
-      wallMs: Number.parseInt(parts[0], 16),
-      logical: Number.parseInt(parts[1], 16),
-      nodeId: parts.slice(2).join("-")
-    };
-  }
-  /**
-   * Builds the string form of a clock reading, which sorts in the same order as the reading itself.
-   *
-   * @param wallMs - Wall-clock milliseconds since the Unix epoch.
-   * @param logical - Counter that orders events sharing one millisecond.
-   * @param nodeId - Identifier of the node taking the reading.
-   * @returns The encoded stamp.
-   */
-  static encode(wallMs, logical, nodeId) {
-    const wallHex = wallMs.toString(16).padStart(12, "0");
-    const logicalHex = logical.toString(16).padStart(4, "0");
-    return `${wallHex}-${logicalHex}-${nodeId}`;
-  }
-};
-
 // src/core/sync/conflict/lww.ts
 var LWWResolver = class {
   /**
-   * Takes the incoming row when its stamp is higher, and keeps the local row otherwise.
+   * Returns the incoming row when its stamp is higher, and the local row otherwise.
    *
    * @param ctx - The local and incoming versions of one row.
    * @returns Which version to write.
@@ -344,6 +258,21 @@ var RowWriter = class {
 };
 
 // src/core/sync/batch-applier.ts
+async function resolveConflict(resolver, ctx) {
+  try {
+    const changeResolver = typeof resolver === "function" ? resolver(ctx.table) : resolver;
+    return await changeResolver.resolve(ctx);
+  } catch (err) {
+    if (err instanceof ConflictError) throw err;
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new ConflictError(
+      `Conflict resolution failed for table '${ctx.table}' row '${ctx.rowId}': ${reason}`,
+      ctx.table,
+      ctx.rowId,
+      err
+    );
+  }
+}
 var BatchApplier = class {
   constructor(conn, localNodeId, hlc, pkResolver, getLastAppliedSeq, tracker, changesTable = CHANGES_TABLE, beforeApply) {
     this.conn = conn;
@@ -455,10 +384,10 @@ var BatchApplier = class {
     return { ...result, droppedTables };
   }
   /**
-   * Applies one pulled transaction whose changes are read from disk in
-   * batches so that a transaction of any size is applied with bounded memory.
-   * The whole group runs in one local transaction: the batches, the echo
-   * stamping, and `withinTx` commit together or not at all.
+   * Applies one staged transaction, reading its changes from `source` one batch
+   * at a time so that memory use stays bounded for a transaction of any size.
+   * The method writes every batch, the echo stamps, and the `withinTx` work
+   * inside one local transaction, so a failure at any step rolls all of it back.
    */
   async applyStagedGroup(options) {
     const { source, resolver, withinTx } = options;
@@ -539,8 +468,7 @@ var BatchApplier = class {
       newData: existingRow,
       oldData: null
     };
-    const changeResolver = typeof resolver === "function" ? resolver(change.table) : resolver;
-    const resolution = await changeResolver.resolve({
+    const resolution = await resolveConflict(resolver, {
       table: change.table,
       rowId: change.rowId,
       localChange,
@@ -714,4 +642,4 @@ var StampOps = class {
   }
 };
 
-export { BatchApplier, BatchReader, HLC, HLC_CLOCK_META_KEY, LWWResolver, REMOTE_ORIGIN_NODE_ID, StampOps, Transaction, isWellFormedHlc, loadPersistedHlc, recordLocalColumnVersions };
+export { BatchApplier, BatchReader, HLC_CLOCK_META_KEY, LWWResolver, REMOTE_ORIGIN_NODE_ID, StampOps, Transaction, isWellFormedHlc, loadPersistedHlc, recordLocalColumnVersions };

package/dist/chunk-ADNWEHGZ.mjs

@@ -0,0 +1,299 @@
+import { TransportError } from './chunk-KU32OT4H.mjs';
+
+// src/transport/grpc/codec.ts
+var PROTO_UINT32_MAX = 4294967295;
+function toColumnValue(value) {
+  if (value === null || value === void 0) {
+    return { nullValue: true };
+  }
+  if (typeof value === "string") {
+    return { stringValue: value };
+  }
+  if (typeof value === "bigint") {
+    return { intValue: value };
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return { intValue: BigInt(value) };
+    }
+    return { floatValue: value };
+  }
+  if (typeof value === "boolean") {
+    return { boolValue: value };
+  }
+  if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+    return { blobValue: Buffer.from(value) };
+  }
+  throw new TypeError(
+    `Unsupported value type for ColumnValue conversion: ${typeof value} (${Object.prototype.toString.call(value)})`
+  );
+}
+function fromColumnValue(cv) {
+  if (cv.nullValue !== void 0) return null;
+  if (cv.stringValue !== void 0) return cv.stringValue;
+  if (cv.intValue !== void 0) return cv.intValue;
+  if (cv.floatValue !== void 0) return cv.floatValue;
+  if (cv.blobValue !== void 0) return cv.blobValue;
+  if (cv.boolValue !== void 0) return cv.boolValue;
+  return null;
+}
+function toRowData(record) {
+  if (record === null || record === void 0) return void 0;
+  const fields = {};
+  for (const [key, value] of Object.entries(record)) {
+    fields[key] = toColumnValue(value);
+  }
+  return { fields };
+}
+function fromRowData(rowData) {
+  if (rowData === void 0) return null;
+  const result = {};
+  for (const [key, cv] of Object.entries(rowData.fields)) {
+    result[key] = fromColumnValue(cv);
+  }
+  return result;
+}
+function toProtoChange(change) {
+  return {
+    table: change.table,
+    operation: change.operation,
+    rowId: change.rowId,
+    primaryKey: toRowData(change.primaryKey),
+    hlc: change.hlc,
+    txId: change.txId,
+    nodeId: change.nodeId,
+    newData: toRowData(change.newData),
+    oldData: toRowData(change.oldData),
+    ddlStatement: change.ddlStatement ?? ""
+  };
+}
+function fromProtoChange(proto) {
+  return {
+    table: proto.table,
+    operation: proto.operation,
+    rowId: proto.rowId,
+    primaryKey: fromRowData(proto.primaryKey) ?? {},
+    hlc: proto.hlc,
+    txId: proto.txId,
+    nodeId: proto.nodeId,
+    newData: fromRowData(proto.newData),
+    oldData: fromRowData(proto.oldData),
+    ddlStatement: proto.ddlStatement || void 0
+  };
+}
+function toBatchPayload(batch) {
+  return {
+    sourceNodeId: batch.sourceNodeId,
+    batchId: batch.batchId,
+    fromSeq: batch.fromSeq,
+    toSeq: batch.toSeq,
+    hlcRange: { min: batch.hlcRange.min, max: batch.hlcRange.max },
+    changes: batch.changes.map(toProtoChange),
+    checksum: batch.checksum,
+    groupId: batch.groupId ?? "",
+    primaryTerm: batch.primaryTerm ?? 0n
+  };
+}
+function fromBatchPayload(payload) {
+  return {
+    sourceNodeId: payload.sourceNodeId,
+    batchId: payload.batchId,
+    fromSeq: payload.fromSeq,
+    toSeq: payload.toSeq,
+    hlcRange: {
+      min: payload.hlcRange?.min ?? "",
+      max: payload.hlcRange?.max ?? ""
+    },
+    changes: payload.changes.map(fromProtoChange),
+    checksum: payload.checksum,
+    groupId: payload.groupId || void 0,
+    primaryTerm: payload.primaryTerm === 0n ? void 0 : payload.primaryTerm
+  };
+}
+function toAckPayload(ack) {
+  return {
+    batchId: ack.batchId,
+    ackedSeq: ack.ackedSeq,
+    nodeId: ack.nodeId,
+    groupId: ack.groupId ?? "",
+    primaryTerm: ack.primaryTerm ?? 0n
+  };
+}
+function fromAckPayload(payload) {
+  return {
+    batchId: payload.batchId,
+    ackedSeq: payload.ackedSeq,
+    nodeId: payload.nodeId,
+    groupId: payload.groupId || void 0,
+    primaryTerm: payload.primaryTerm === 0n ? void 0 : payload.primaryTerm
+  };
+}
+function toSyncRequestPayload(req) {
+  return {
+    requestId: req.requestId,
+    joinerNodeId: req.joinerNodeId,
+    completedTables: req.completedTables,
+    groupId: req.groupId ?? "",
+    primaryTerm: req.primaryTerm ?? 0n,
+    supportsStreamVerification: req.supportsStreamVerification === true
+  };
+}
+function fromSyncRequestPayload(p) {
+  return {
+    requestId: p.requestId,
+    joinerNodeId: p.joinerNodeId,
+    completedTables: p.completedTables,
+    supportsStreamVerification: p.supportsStreamVerification === true ? true : void 0,
+    groupId: p.groupId || void 0,
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm
+  };
+}
+function toSyncBatchPayload(batch) {
+  return {
+    requestId: batch.requestId,
+    table: batch.table,
+    batchIndex: batch.batchIndex,
+    rows: batch.rows.map((row) => toRowData(row) ?? { fields: {} }),
+    schema: batch.schema ?? [],
+    checksum: batch.checksum,
+    isLastBatchForTable: batch.isLastBatchForTable,
+    groupId: batch.groupId ?? "",
+    primaryTerm: batch.primaryTerm ?? 0n,
+    totalTables: batch.totalTables ?? 0
+  };
+}
+function fromSyncBatchPayload(p) {
+  return {
+    requestId: p.requestId,
+    table: p.table,
+    batchIndex: p.batchIndex,
+    rows: p.rows.map((r) => fromRowData(r) ?? {}),
+    schema: p.schema.length > 0 ? p.schema : void 0,
+    checksum: p.checksum,
+    isLastBatchForTable: p.isLastBatchForTable,
+    groupId: p.groupId || void 0,
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm,
+    totalTables: p.totalTables === 0 ? void 0 : p.totalTables
+  };
+}
+function toSyncCompletePayload(complete) {
+  return {
+    requestId: complete.requestId,
+    snapshotSeq: complete.snapshotSeq,
+    manifests: complete.manifests.map((m) => ({
+      table: m.table,
+      rowCount: m.rowCount,
+      pkHash: m.pkHash ?? "",
+      batchDigest: m.batchDigest ?? ""
+    })),
+    groupId: complete.groupId ?? "",
+    primaryTerm: complete.primaryTerm ?? 0n
+  };
+}
+function fromSyncCompletePayload(p) {
+  return {
+    requestId: p.requestId,
+    snapshotSeq: p.snapshotSeq,
+    manifests: p.manifests.map(
+      (m) => ({
+        table: m.table,
+        rowCount: m.rowCount,
+        pkHash: m.pkHash || void 0,
+        batchDigest: m.batchDigest || void 0
+      })
+    ),
+    groupId: p.groupId || void 0,
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm
+  };
+}
+function toSyncAckPayload(ack) {
+  return {
+    requestId: ack.requestId,
+    joinerNodeId: ack.joinerNodeId,
+    table: ack.table,
+    batchIndex: ack.batchIndex,
+    success: ack.success,
+    error: ack.error ?? "",
+    groupId: ack.groupId ?? "",
+    primaryTerm: ack.primaryTerm ?? 0n
+  };
+}
+function fromSyncAckPayload(p) {
+  return {
+    requestId: p.requestId,
+    joinerNodeId: p.joinerNodeId,
+    table: p.table,
+    batchIndex: p.batchIndex,
+    success: p.success,
+    error: p.error || void 0,
+    groupId: p.groupId || void 0,
+    primaryTerm: p.primaryTerm === 0n ? void 0 : p.primaryTerm
+  };
+}
+function toForwardRequest(req) {
+  const statements = req.statements.map((s) => {
+    const namedParams = {};
+    const positionalParams = [];
+    if (s.params !== void 0 && s.params !== null) {
+      if (Array.isArray(s.params)) {
+        for (const v of s.params) {
+          positionalParams.push(toColumnValue(v));
+        }
+      } else {
+        for (const [k, v] of Object.entries(s.params)) {
+          namedParams[k] = toColumnValue(v);
+        }
+      }
+    }
+    return { sql: s.sql, namedParams, positionalParams };
+  });
+  const writeConcernTimeoutMs = req.writeConcern?.timeoutMs ?? 0;
+  if (writeConcernTimeoutMs > PROTO_UINT32_MAX) {
+    throw new TransportError(
+      `Write concern timeoutMs ${writeConcernTimeoutMs} exceeds the ${PROTO_UINT32_MAX} ms that a forwarded write can carry`
+    );
+  }
+  return {
+    requestId: req.requestId,
+    statements,
+    groupId: req.groupId ?? "",
+    primaryTerm: req.primaryTerm ?? 0n,
+    writeConcernLevel: req.writeConcern?.level ?? "",
+    writeConcernTimeoutMs
+  };
+}
+function fromForwardWriteConcern(proto) {
+  const level = proto.writeConcernLevel;
+  if (level === "") return void 0;
+  if (level !== "local" && level !== "majority" && level !== "all") {
+    throw new TransportError(`Forward request states an unknown write concern level '${level}'`);
+  }
+  return proto.writeConcernTimeoutMs > 0 ? { level, timeoutMs: proto.writeConcernTimeoutMs } : { level };
+}
+function fromForwardRequest(proto) {
+  const statements = proto.statements.map((s) => {
+    const hasNamed = Object.keys(s.namedParams).length > 0;
+    const hasPositional = s.positionalParams.length > 0;
+    let params;
+    if (hasNamed) {
+      const named = {};
+      for (const [k, cv] of Object.entries(s.namedParams)) {
+        named[k] = fromColumnValue(cv);
+      }
+      params = named;
+    } else if (hasPositional) {
+      params = s.positionalParams.map(fromColumnValue);
+    }
+    return { sql: s.sql, params };
+  });
+  const writeConcern = fromForwardWriteConcern(proto);
+  return {
+    requestId: proto.requestId,
+    statements,
+    groupId: proto.groupId || void 0,
+    primaryTerm: proto.primaryTerm === 0n ? void 0 : proto.primaryTerm,
+    ...writeConcern === void 0 ? {} : { writeConcern }
+  };
+}
+
+export { fromAckPayload, fromBatchPayload, fromColumnValue, fromForwardRequest, fromSyncAckPayload, fromSyncBatchPayload, fromSyncCompletePayload, fromSyncRequestPayload, toAckPayload, toBatchPayload, toColumnValue, toForwardRequest, toSyncAckPayload, toSyncBatchPayload, toSyncCompletePayload, toSyncRequestPayload };