@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/transport/grpc.mjs

@@ -0,0 +1,3341 @@
+import { TransportError } from '../chunk-UVMVN3OT.mjs';
+import '../chunk-O7BHI3CF.mjs';
+import { makeGenericClientConstructor, Metadata, Server, status, ServerCredentials, credentials } from '@grpc/grpc-js';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import { readFileSync } from 'fs';
+import { HealthImplementation } from 'grpc-health-check';
+
+// src/transport/grpc/codec.ts
+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
+  };
+}
+function fromSyncRequestPayload(p) {
+  return {
+    requestId: p.requestId,
+    joinerNodeId: p.joinerNodeId,
+    completedTables: p.completedTables,
+    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
+  };
+}
+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
+  };
+}
+function toSyncCompletePayload(complete) {
+  return {
+    requestId: complete.requestId,
+    snapshotSeq: complete.snapshotSeq,
+    manifests: complete.manifests.map((m) => ({
+      table: m.table,
+      rowCount: m.rowCount,
+      pkHash: m.pkHash
+    })),
+    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
+      })
+    ),
+    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 };
+  });
+  return { requestId: req.requestId, statements, groupId: req.groupId ?? "", primaryTerm: req.primaryTerm ?? 0n };
+}
+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 };
+  });
+  return {
+    requestId: proto.requestId,
+    statements,
+    groupId: proto.groupId || void 0,
+    primaryTerm: proto.primaryTerm === 0n ? void 0 : proto.primaryTerm
+  };
+}
+function createBaseColumnValue() {
+  return {
+    nullValue: void 0,
+    stringValue: void 0,
+    intValue: void 0,
+    floatValue: void 0,
+    blobValue: void 0,
+    boolValue: void 0
+  };
+}
+var ColumnValue = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.nullValue !== void 0) {
+      writer.uint32(8).bool(message.nullValue);
+    }
+    if (message.stringValue !== void 0) {
+      writer.uint32(18).string(message.stringValue);
+    }
+    if (message.intValue !== void 0) {
+      if (BigInt.asIntN(64, message.intValue) !== message.intValue) {
+        throw new globalThis.Error("value provided for field message.intValue of type int64 too large");
+      }
+      writer.uint32(24).int64(message.intValue);
+    }
+    if (message.floatValue !== void 0) {
+      writer.uint32(33).double(message.floatValue);
+    }
+    if (message.blobValue !== void 0) {
+      writer.uint32(42).bytes(message.blobValue);
+    }
+    if (message.boolValue !== void 0) {
+      writer.uint32(48).bool(message.boolValue);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseColumnValue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.nullValue = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.stringValue = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.intValue = reader.int64();
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+          message.floatValue = reader.double();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.blobValue = Buffer.from(reader.bytes());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.boolValue = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nullValue: isSet(object.nullValue) ? globalThis.Boolean(object.nullValue) : isSet(object.null_value) ? globalThis.Boolean(object.null_value) : void 0,
+      stringValue: isSet(object.stringValue) ? globalThis.String(object.stringValue) : isSet(object.string_value) ? globalThis.String(object.string_value) : void 0,
+      intValue: isSet(object.intValue) ? BigInt(object.intValue) : isSet(object.int_value) ? BigInt(object.int_value) : void 0,
+      floatValue: isSet(object.floatValue) ? globalThis.Number(object.floatValue) : isSet(object.float_value) ? globalThis.Number(object.float_value) : void 0,
+      blobValue: isSet(object.blobValue) ? Buffer.from(bytesFromBase64(object.blobValue)) : isSet(object.blob_value) ? Buffer.from(bytesFromBase64(object.blob_value)) : void 0,
+      boolValue: isSet(object.boolValue) ? globalThis.Boolean(object.boolValue) : isSet(object.bool_value) ? globalThis.Boolean(object.bool_value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nullValue !== void 0) {
+      obj.nullValue = message.nullValue;
+    }
+    if (message.stringValue !== void 0) {
+      obj.stringValue = message.stringValue;
+    }
+    if (message.intValue !== void 0) {
+      obj.intValue = message.intValue.toString();
+    }
+    if (message.floatValue !== void 0) {
+      obj.floatValue = message.floatValue;
+    }
+    if (message.blobValue !== void 0) {
+      obj.blobValue = base64FromBytes(message.blobValue);
+    }
+    if (message.boolValue !== void 0) {
+      obj.boolValue = message.boolValue;
+    }
+    return obj;
+  },
+  create(base) {
+    return ColumnValue.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseColumnValue();
+    message.nullValue = object.nullValue ?? void 0;
+    message.stringValue = object.stringValue ?? void 0;
+    message.intValue = object.intValue ?? void 0;
+    message.floatValue = object.floatValue ?? void 0;
+    message.blobValue = object.blobValue ?? void 0;
+    message.boolValue = object.boolValue ?? void 0;
+    return message;
+  }
+};
+function createBaseRowData() {
+  return { fields: {} };
+}
+var RowData = {
+  encode(message, writer = new BinaryWriter()) {
+    globalThis.Object.entries(message.fields).forEach(([key, value]) => {
+      RowData_FieldsEntry.encode({ key, value }, writer.uint32(10).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseRowData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          const entry1 = RowData_FieldsEntry.decode(reader, reader.uint32());
+          if (entry1.value !== void 0) {
+            message.fields[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      fields: isObject(object.fields) ? globalThis.Object.entries(object.fields).reduce(
+        (acc, [key, value]) => {
+          acc[key] = ColumnValue.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.fields) {
+      const entries = globalThis.Object.entries(message.fields);
+      if (entries.length > 0) {
+        obj.fields = {};
+        entries.forEach(([k, v]) => {
+          obj.fields[k] = ColumnValue.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return RowData.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRowData();
+    message.fields = globalThis.Object.entries(object.fields ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = ColumnValue.fromPartial(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseRowData_FieldsEntry() {
+  return { key: "", value: void 0 };
+}
+var RowData_FieldsEntry = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      ColumnValue.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseRowData_FieldsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = ColumnValue.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? ColumnValue.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = ColumnValue.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return RowData_FieldsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRowData_FieldsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? ColumnValue.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseHlcRange() {
+  return { min: "", max: "" };
+}
+var HlcRange = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.min !== "") {
+      writer.uint32(10).string(message.min);
+    }
+    if (message.max !== "") {
+      writer.uint32(18).string(message.max);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseHlcRange();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.min = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.max = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      min: isSet(object.min) ? globalThis.String(object.min) : "",
+      max: isSet(object.max) ? globalThis.String(object.max) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.min !== "") {
+      obj.min = message.min;
+    }
+    if (message.max !== "") {
+      obj.max = message.max;
+    }
+    return obj;
+  },
+  create(base) {
+    return HlcRange.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseHlcRange();
+    message.min = object.min ?? "";
+    message.max = object.max ?? "";
+    return message;
+  }
+};
+function createBaseReplicationChange() {
+  return {
+    table: "",
+    operation: "",
+    rowId: "",
+    primaryKey: void 0,
+    hlc: "",
+    txId: "",
+    nodeId: "",
+    newData: void 0,
+    oldData: void 0,
+    ddlStatement: ""
+  };
+}
+var ReplicationChange = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.table !== "") {
+      writer.uint32(10).string(message.table);
+    }
+    if (message.operation !== "") {
+      writer.uint32(18).string(message.operation);
+    }
+    if (message.rowId !== "") {
+      writer.uint32(26).string(message.rowId);
+    }
+    if (message.primaryKey !== void 0) {
+      RowData.encode(message.primaryKey, writer.uint32(34).fork()).join();
+    }
+    if (message.hlc !== "") {
+      writer.uint32(42).string(message.hlc);
+    }
+    if (message.txId !== "") {
+      writer.uint32(50).string(message.txId);
+    }
+    if (message.nodeId !== "") {
+      writer.uint32(58).string(message.nodeId);
+    }
+    if (message.newData !== void 0) {
+      RowData.encode(message.newData, writer.uint32(66).fork()).join();
+    }
+    if (message.oldData !== void 0) {
+      RowData.encode(message.oldData, writer.uint32(74).fork()).join();
+    }
+    if (message.ddlStatement !== "") {
+      writer.uint32(82).string(message.ddlStatement);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseReplicationChange();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.table = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.operation = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.rowId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.primaryKey = RowData.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.hlc = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.txId = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.nodeId = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.newData = RowData.decode(reader, reader.uint32());
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.oldData = RowData.decode(reader, reader.uint32());
+          continue;
+        }
+        case 10: {
+          if (tag !== 82) {
+            break;
+          }
+          message.ddlStatement = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      table: isSet(object.table) ? globalThis.String(object.table) : "",
+      operation: isSet(object.operation) ? globalThis.String(object.operation) : "",
+      rowId: isSet(object.rowId) ? globalThis.String(object.rowId) : isSet(object.row_id) ? globalThis.String(object.row_id) : "",
+      primaryKey: isSet(object.primaryKey) ? RowData.fromJSON(object.primaryKey) : isSet(object.primary_key) ? RowData.fromJSON(object.primary_key) : void 0,
+      hlc: isSet(object.hlc) ? globalThis.String(object.hlc) : "",
+      txId: isSet(object.txId) ? globalThis.String(object.txId) : isSet(object.tx_id) ? globalThis.String(object.tx_id) : "",
+      nodeId: isSet(object.nodeId) ? globalThis.String(object.nodeId) : isSet(object.node_id) ? globalThis.String(object.node_id) : "",
+      newData: isSet(object.newData) ? RowData.fromJSON(object.newData) : isSet(object.new_data) ? RowData.fromJSON(object.new_data) : void 0,
+      oldData: isSet(object.oldData) ? RowData.fromJSON(object.oldData) : isSet(object.old_data) ? RowData.fromJSON(object.old_data) : void 0,
+      ddlStatement: isSet(object.ddlStatement) ? globalThis.String(object.ddlStatement) : isSet(object.ddl_statement) ? globalThis.String(object.ddl_statement) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.table !== "") {
+      obj.table = message.table;
+    }
+    if (message.operation !== "") {
+      obj.operation = message.operation;
+    }
+    if (message.rowId !== "") {
+      obj.rowId = message.rowId;
+    }
+    if (message.primaryKey !== void 0) {
+      obj.primaryKey = RowData.toJSON(message.primaryKey);
+    }
+    if (message.hlc !== "") {
+      obj.hlc = message.hlc;
+    }
+    if (message.txId !== "") {
+      obj.txId = message.txId;
+    }
+    if (message.nodeId !== "") {
+      obj.nodeId = message.nodeId;
+    }
+    if (message.newData !== void 0) {
+      obj.newData = RowData.toJSON(message.newData);
+    }
+    if (message.oldData !== void 0) {
+      obj.oldData = RowData.toJSON(message.oldData);
+    }
+    if (message.ddlStatement !== "") {
+      obj.ddlStatement = message.ddlStatement;
+    }
+    return obj;
+  },
+  create(base) {
+    return ReplicationChange.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseReplicationChange();
+    message.table = object.table ?? "";
+    message.operation = object.operation ?? "";
+    message.rowId = object.rowId ?? "";
+    message.primaryKey = object.primaryKey !== void 0 && object.primaryKey !== null ? RowData.fromPartial(object.primaryKey) : void 0;
+    message.hlc = object.hlc ?? "";
+    message.txId = object.txId ?? "";
+    message.nodeId = object.nodeId ?? "";
+    message.newData = object.newData !== void 0 && object.newData !== null ? RowData.fromPartial(object.newData) : void 0;
+    message.oldData = object.oldData !== void 0 && object.oldData !== null ? RowData.fromPartial(object.oldData) : void 0;
+    message.ddlStatement = object.ddlStatement ?? "";
+    return message;
+  }
+};
+function createBaseBatchPayload() {
+  return {
+    sourceNodeId: "",
+    batchId: "",
+    fromSeq: 0n,
+    toSeq: 0n,
+    hlcRange: void 0,
+    changes: [],
+    checksum: "",
+    groupId: "",
+    primaryTerm: 0n
+  };
+}
+var BatchPayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.sourceNodeId !== "") {
+      writer.uint32(10).string(message.sourceNodeId);
+    }
+    if (message.batchId !== "") {
+      writer.uint32(18).string(message.batchId);
+    }
+    if (message.fromSeq !== 0n) {
+      if (BigInt.asIntN(64, message.fromSeq) !== message.fromSeq) {
+        throw new globalThis.Error("value provided for field message.fromSeq of type int64 too large");
+      }
+      writer.uint32(24).int64(message.fromSeq);
+    }
+    if (message.toSeq !== 0n) {
+      if (BigInt.asIntN(64, message.toSeq) !== message.toSeq) {
+        throw new globalThis.Error("value provided for field message.toSeq of type int64 too large");
+      }
+      writer.uint32(32).int64(message.toSeq);
+    }
+    if (message.hlcRange !== void 0) {
+      HlcRange.encode(message.hlcRange, writer.uint32(42).fork()).join();
+    }
+    for (const v of message.changes) {
+      ReplicationChange.encode(v, writer.uint32(50).fork()).join();
+    }
+    if (message.checksum !== "") {
+      writer.uint32(58).string(message.checksum);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(66).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(72).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseBatchPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sourceNodeId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.batchId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.fromSeq = reader.int64();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.toSeq = reader.int64();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.hlcRange = HlcRange.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.changes.push(ReplicationChange.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.checksum = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sourceNodeId: isSet(object.sourceNodeId) ? globalThis.String(object.sourceNodeId) : isSet(object.source_node_id) ? globalThis.String(object.source_node_id) : "",
+      batchId: isSet(object.batchId) ? globalThis.String(object.batchId) : isSet(object.batch_id) ? globalThis.String(object.batch_id) : "",
+      fromSeq: isSet(object.fromSeq) ? BigInt(object.fromSeq) : isSet(object.from_seq) ? BigInt(object.from_seq) : 0n,
+      toSeq: isSet(object.toSeq) ? BigInt(object.toSeq) : isSet(object.to_seq) ? BigInt(object.to_seq) : 0n,
+      hlcRange: isSet(object.hlcRange) ? HlcRange.fromJSON(object.hlcRange) : isSet(object.hlc_range) ? HlcRange.fromJSON(object.hlc_range) : void 0,
+      changes: globalThis.Array.isArray(object?.changes) ? object.changes.map((e) => ReplicationChange.fromJSON(e)) : [],
+      checksum: isSet(object.checksum) ? globalThis.String(object.checksum) : "",
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sourceNodeId !== "") {
+      obj.sourceNodeId = message.sourceNodeId;
+    }
+    if (message.batchId !== "") {
+      obj.batchId = message.batchId;
+    }
+    if (message.fromSeq !== 0n) {
+      obj.fromSeq = message.fromSeq.toString();
+    }
+    if (message.toSeq !== 0n) {
+      obj.toSeq = message.toSeq.toString();
+    }
+    if (message.hlcRange !== void 0) {
+      obj.hlcRange = HlcRange.toJSON(message.hlcRange);
+    }
+    if (message.changes?.length) {
+      obj.changes = message.changes.map((e) => ReplicationChange.toJSON(e));
+    }
+    if (message.checksum !== "") {
+      obj.checksum = message.checksum;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return BatchPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseBatchPayload();
+    message.sourceNodeId = object.sourceNodeId ?? "";
+    message.batchId = object.batchId ?? "";
+    message.fromSeq = object.fromSeq ?? 0n;
+    message.toSeq = object.toSeq ?? 0n;
+    message.hlcRange = object.hlcRange !== void 0 && object.hlcRange !== null ? HlcRange.fromPartial(object.hlcRange) : void 0;
+    message.changes = object.changes?.map((e) => ReplicationChange.fromPartial(e)) || [];
+    message.checksum = object.checksum ?? "";
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseAckPayload() {
+  return { batchId: "", ackedSeq: 0n, nodeId: "", groupId: "", primaryTerm: 0n };
+}
+var AckPayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.batchId !== "") {
+      writer.uint32(10).string(message.batchId);
+    }
+    if (message.ackedSeq !== 0n) {
+      if (BigInt.asIntN(64, message.ackedSeq) !== message.ackedSeq) {
+        throw new globalThis.Error("value provided for field message.ackedSeq of type int64 too large");
+      }
+      writer.uint32(16).int64(message.ackedSeq);
+    }
+    if (message.nodeId !== "") {
+      writer.uint32(26).string(message.nodeId);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(34).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(40).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAckPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.batchId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.ackedSeq = reader.int64();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.nodeId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      batchId: isSet(object.batchId) ? globalThis.String(object.batchId) : isSet(object.batch_id) ? globalThis.String(object.batch_id) : "",
+      ackedSeq: isSet(object.ackedSeq) ? BigInt(object.ackedSeq) : isSet(object.acked_seq) ? BigInt(object.acked_seq) : 0n,
+      nodeId: isSet(object.nodeId) ? globalThis.String(object.nodeId) : isSet(object.node_id) ? globalThis.String(object.node_id) : "",
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.batchId !== "") {
+      obj.batchId = message.batchId;
+    }
+    if (message.ackedSeq !== 0n) {
+      obj.ackedSeq = message.ackedSeq.toString();
+    }
+    if (message.nodeId !== "") {
+      obj.nodeId = message.nodeId;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return AckPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseAckPayload();
+    message.batchId = object.batchId ?? "";
+    message.ackedSeq = object.ackedSeq ?? 0n;
+    message.nodeId = object.nodeId ?? "";
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseHello() {
+  return { nodeId: "", role: "", groupId: "", primaryTerm: 0n, protocolVersion: "" };
+}
+var Hello = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.nodeId !== "") {
+      writer.uint32(10).string(message.nodeId);
+    }
+    if (message.role !== "") {
+      writer.uint32(18).string(message.role);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(26).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(32).int64(message.primaryTerm);
+    }
+    if (message.protocolVersion !== "") {
+      writer.uint32(42).string(message.protocolVersion);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseHello();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.nodeId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.role = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.protocolVersion = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nodeId: isSet(object.nodeId) ? globalThis.String(object.nodeId) : isSet(object.node_id) ? globalThis.String(object.node_id) : "",
+      role: isSet(object.role) ? globalThis.String(object.role) : "",
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n,
+      protocolVersion: isSet(object.protocolVersion) ? globalThis.String(object.protocolVersion) : isSet(object.protocol_version) ? globalThis.String(object.protocol_version) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nodeId !== "") {
+      obj.nodeId = message.nodeId;
+    }
+    if (message.role !== "") {
+      obj.role = message.role;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    if (message.protocolVersion !== "") {
+      obj.protocolVersion = message.protocolVersion;
+    }
+    return obj;
+  },
+  create(base) {
+    return Hello.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseHello();
+    message.nodeId = object.nodeId ?? "";
+    message.role = object.role ?? "";
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    message.protocolVersion = object.protocolVersion ?? "";
+    return message;
+  }
+};
+function createBaseReplicationMessage() {
+  return { hello: void 0, batch: void 0, ack: void 0 };
+}
+var ReplicationMessage = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.hello !== void 0) {
+      Hello.encode(message.hello, writer.uint32(10).fork()).join();
+    }
+    if (message.batch !== void 0) {
+      BatchPayload.encode(message.batch, writer.uint32(18).fork()).join();
+    }
+    if (message.ack !== void 0) {
+      AckPayload.encode(message.ack, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseReplicationMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.hello = Hello.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.batch = BatchPayload.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.ack = AckPayload.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      hello: isSet(object.hello) ? Hello.fromJSON(object.hello) : void 0,
+      batch: isSet(object.batch) ? BatchPayload.fromJSON(object.batch) : void 0,
+      ack: isSet(object.ack) ? AckPayload.fromJSON(object.ack) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.hello !== void 0) {
+      obj.hello = Hello.toJSON(message.hello);
+    }
+    if (message.batch !== void 0) {
+      obj.batch = BatchPayload.toJSON(message.batch);
+    }
+    if (message.ack !== void 0) {
+      obj.ack = AckPayload.toJSON(message.ack);
+    }
+    return obj;
+  },
+  create(base) {
+    return ReplicationMessage.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseReplicationMessage();
+    message.hello = object.hello !== void 0 && object.hello !== null ? Hello.fromPartial(object.hello) : void 0;
+    message.batch = object.batch !== void 0 && object.batch !== null ? BatchPayload.fromPartial(object.batch) : void 0;
+    message.ack = object.ack !== void 0 && object.ack !== null ? AckPayload.fromPartial(object.ack) : void 0;
+    return message;
+  }
+};
+function createBaseSyncRequestPayload() {
+  return { requestId: "", joinerNodeId: "", completedTables: [], groupId: "", primaryTerm: 0n };
+}
+var SyncRequestPayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    if (message.joinerNodeId !== "") {
+      writer.uint32(18).string(message.joinerNodeId);
+    }
+    for (const v of message.completedTables) {
+      writer.uint32(26).string(v);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(34).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(40).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncRequestPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.joinerNodeId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.completedTables.push(reader.string());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      joinerNodeId: isSet(object.joinerNodeId) ? globalThis.String(object.joinerNodeId) : isSet(object.joiner_node_id) ? globalThis.String(object.joiner_node_id) : "",
+      completedTables: globalThis.Array.isArray(object?.completedTables) ? object.completedTables.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.completed_tables) ? object.completed_tables.map((e) => globalThis.String(e)) : [],
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.joinerNodeId !== "") {
+      obj.joinerNodeId = message.joinerNodeId;
+    }
+    if (message.completedTables?.length) {
+      obj.completedTables = message.completedTables;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncRequestPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncRequestPayload();
+    message.requestId = object.requestId ?? "";
+    message.joinerNodeId = object.joinerNodeId ?? "";
+    message.completedTables = object.completedTables?.map((e) => e) || [];
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseSyncBatchPayload() {
+  return {
+    requestId: "",
+    table: "",
+    batchIndex: 0,
+    rows: [],
+    schema: [],
+    checksum: "",
+    isLastBatchForTable: false,
+    groupId: "",
+    primaryTerm: 0n
+  };
+}
+var SyncBatchPayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    if (message.table !== "") {
+      writer.uint32(18).string(message.table);
+    }
+    if (message.batchIndex !== 0) {
+      writer.uint32(24).int32(message.batchIndex);
+    }
+    for (const v of message.rows) {
+      RowData.encode(v, writer.uint32(34).fork()).join();
+    }
+    for (const v of message.schema) {
+      writer.uint32(42).string(v);
+    }
+    if (message.checksum !== "") {
+      writer.uint32(50).string(message.checksum);
+    }
+    if (message.isLastBatchForTable !== false) {
+      writer.uint32(56).bool(message.isLastBatchForTable);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(66).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(72).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncBatchPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.table = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.batchIndex = reader.int32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.rows.push(RowData.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.schema.push(reader.string());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.checksum = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.isLastBatchForTable = reader.bool();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      table: isSet(object.table) ? globalThis.String(object.table) : "",
+      batchIndex: isSet(object.batchIndex) ? globalThis.Number(object.batchIndex) : isSet(object.batch_index) ? globalThis.Number(object.batch_index) : 0,
+      rows: globalThis.Array.isArray(object?.rows) ? object.rows.map((e) => RowData.fromJSON(e)) : [],
+      schema: globalThis.Array.isArray(object?.schema) ? object.schema.map((e) => globalThis.String(e)) : [],
+      checksum: isSet(object.checksum) ? globalThis.String(object.checksum) : "",
+      isLastBatchForTable: isSet(object.isLastBatchForTable) ? globalThis.Boolean(object.isLastBatchForTable) : isSet(object.is_last_batch_for_table) ? globalThis.Boolean(object.is_last_batch_for_table) : false,
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.table !== "") {
+      obj.table = message.table;
+    }
+    if (message.batchIndex !== 0) {
+      obj.batchIndex = Math.round(message.batchIndex);
+    }
+    if (message.rows?.length) {
+      obj.rows = message.rows.map((e) => RowData.toJSON(e));
+    }
+    if (message.schema?.length) {
+      obj.schema = message.schema;
+    }
+    if (message.checksum !== "") {
+      obj.checksum = message.checksum;
+    }
+    if (message.isLastBatchForTable !== false) {
+      obj.isLastBatchForTable = message.isLastBatchForTable;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncBatchPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncBatchPayload();
+    message.requestId = object.requestId ?? "";
+    message.table = object.table ?? "";
+    message.batchIndex = object.batchIndex ?? 0;
+    message.rows = object.rows?.map((e) => RowData.fromPartial(e)) || [];
+    message.schema = object.schema?.map((e) => e) || [];
+    message.checksum = object.checksum ?? "";
+    message.isLastBatchForTable = object.isLastBatchForTable ?? false;
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseSyncCompletePayload() {
+  return { requestId: "", snapshotSeq: 0n, manifests: [], groupId: "", primaryTerm: 0n };
+}
+var SyncCompletePayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    if (message.snapshotSeq !== 0n) {
+      if (BigInt.asIntN(64, message.snapshotSeq) !== message.snapshotSeq) {
+        throw new globalThis.Error("value provided for field message.snapshotSeq of type int64 too large");
+      }
+      writer.uint32(16).int64(message.snapshotSeq);
+    }
+    for (const v of message.manifests) {
+      SyncTableManifest.encode(v, writer.uint32(26).fork()).join();
+    }
+    if (message.groupId !== "") {
+      writer.uint32(34).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(40).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncCompletePayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.snapshotSeq = reader.int64();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.manifests.push(SyncTableManifest.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      snapshotSeq: isSet(object.snapshotSeq) ? BigInt(object.snapshotSeq) : isSet(object.snapshot_seq) ? BigInt(object.snapshot_seq) : 0n,
+      manifests: globalThis.Array.isArray(object?.manifests) ? object.manifests.map((e) => SyncTableManifest.fromJSON(e)) : [],
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.snapshotSeq !== 0n) {
+      obj.snapshotSeq = message.snapshotSeq.toString();
+    }
+    if (message.manifests?.length) {
+      obj.manifests = message.manifests.map((e) => SyncTableManifest.toJSON(e));
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncCompletePayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncCompletePayload();
+    message.requestId = object.requestId ?? "";
+    message.snapshotSeq = object.snapshotSeq ?? 0n;
+    message.manifests = object.manifests?.map((e) => SyncTableManifest.fromPartial(e)) || [];
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseSyncTableManifest() {
+  return { table: "", rowCount: 0, pkHash: "" };
+}
+var SyncTableManifest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.table !== "") {
+      writer.uint32(10).string(message.table);
+    }
+    if (message.rowCount !== 0) {
+      writer.uint32(16).int32(message.rowCount);
+    }
+    if (message.pkHash !== "") {
+      writer.uint32(26).string(message.pkHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncTableManifest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.table = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.rowCount = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.pkHash = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      table: isSet(object.table) ? globalThis.String(object.table) : "",
+      rowCount: isSet(object.rowCount) ? globalThis.Number(object.rowCount) : isSet(object.row_count) ? globalThis.Number(object.row_count) : 0,
+      pkHash: isSet(object.pkHash) ? globalThis.String(object.pkHash) : isSet(object.pk_hash) ? globalThis.String(object.pk_hash) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.table !== "") {
+      obj.table = message.table;
+    }
+    if (message.rowCount !== 0) {
+      obj.rowCount = Math.round(message.rowCount);
+    }
+    if (message.pkHash !== "") {
+      obj.pkHash = message.pkHash;
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncTableManifest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncTableManifest();
+    message.table = object.table ?? "";
+    message.rowCount = object.rowCount ?? 0;
+    message.pkHash = object.pkHash ?? "";
+    return message;
+  }
+};
+function createBaseSyncAckPayload() {
+  return {
+    requestId: "",
+    joinerNodeId: "",
+    table: "",
+    batchIndex: 0,
+    success: false,
+    error: "",
+    groupId: "",
+    primaryTerm: 0n
+  };
+}
+var SyncAckPayload = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    if (message.joinerNodeId !== "") {
+      writer.uint32(18).string(message.joinerNodeId);
+    }
+    if (message.table !== "") {
+      writer.uint32(26).string(message.table);
+    }
+    if (message.batchIndex !== 0) {
+      writer.uint32(32).int32(message.batchIndex);
+    }
+    if (message.success !== false) {
+      writer.uint32(40).bool(message.success);
+    }
+    if (message.error !== "") {
+      writer.uint32(50).string(message.error);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(58).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(64).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncAckPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.joinerNodeId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.table = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.batchIndex = reader.int32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.success = reader.bool();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.error = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      joinerNodeId: isSet(object.joinerNodeId) ? globalThis.String(object.joinerNodeId) : isSet(object.joiner_node_id) ? globalThis.String(object.joiner_node_id) : "",
+      table: isSet(object.table) ? globalThis.String(object.table) : "",
+      batchIndex: isSet(object.batchIndex) ? globalThis.Number(object.batchIndex) : isSet(object.batch_index) ? globalThis.Number(object.batch_index) : 0,
+      success: isSet(object.success) ? globalThis.Boolean(object.success) : false,
+      error: isSet(object.error) ? globalThis.String(object.error) : "",
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.joinerNodeId !== "") {
+      obj.joinerNodeId = message.joinerNodeId;
+    }
+    if (message.table !== "") {
+      obj.table = message.table;
+    }
+    if (message.batchIndex !== 0) {
+      obj.batchIndex = Math.round(message.batchIndex);
+    }
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
+    if (message.error !== "") {
+      obj.error = message.error;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncAckPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncAckPayload();
+    message.requestId = object.requestId ?? "";
+    message.joinerNodeId = object.joinerNodeId ?? "";
+    message.table = object.table ?? "";
+    message.batchIndex = object.batchIndex ?? 0;
+    message.success = object.success ?? false;
+    message.error = object.error ?? "";
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseSyncMessage() {
+  return {
+    hello: void 0,
+    syncRequest: void 0,
+    syncBatch: void 0,
+    syncComplete: void 0,
+    syncAck: void 0
+  };
+}
+var SyncMessage = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.hello !== void 0) {
+      Hello.encode(message.hello, writer.uint32(10).fork()).join();
+    }
+    if (message.syncRequest !== void 0) {
+      SyncRequestPayload.encode(message.syncRequest, writer.uint32(18).fork()).join();
+    }
+    if (message.syncBatch !== void 0) {
+      SyncBatchPayload.encode(message.syncBatch, writer.uint32(26).fork()).join();
+    }
+    if (message.syncComplete !== void 0) {
+      SyncCompletePayload.encode(message.syncComplete, writer.uint32(34).fork()).join();
+    }
+    if (message.syncAck !== void 0) {
+      SyncAckPayload.encode(message.syncAck, writer.uint32(42).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSyncMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.hello = Hello.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.syncRequest = SyncRequestPayload.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.syncBatch = SyncBatchPayload.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.syncComplete = SyncCompletePayload.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.syncAck = SyncAckPayload.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      hello: isSet(object.hello) ? Hello.fromJSON(object.hello) : void 0,
+      syncRequest: isSet(object.syncRequest) ? SyncRequestPayload.fromJSON(object.syncRequest) : isSet(object.sync_request) ? SyncRequestPayload.fromJSON(object.sync_request) : void 0,
+      syncBatch: isSet(object.syncBatch) ? SyncBatchPayload.fromJSON(object.syncBatch) : isSet(object.sync_batch) ? SyncBatchPayload.fromJSON(object.sync_batch) : void 0,
+      syncComplete: isSet(object.syncComplete) ? SyncCompletePayload.fromJSON(object.syncComplete) : isSet(object.sync_complete) ? SyncCompletePayload.fromJSON(object.sync_complete) : void 0,
+      syncAck: isSet(object.syncAck) ? SyncAckPayload.fromJSON(object.syncAck) : isSet(object.sync_ack) ? SyncAckPayload.fromJSON(object.sync_ack) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.hello !== void 0) {
+      obj.hello = Hello.toJSON(message.hello);
+    }
+    if (message.syncRequest !== void 0) {
+      obj.syncRequest = SyncRequestPayload.toJSON(message.syncRequest);
+    }
+    if (message.syncBatch !== void 0) {
+      obj.syncBatch = SyncBatchPayload.toJSON(message.syncBatch);
+    }
+    if (message.syncComplete !== void 0) {
+      obj.syncComplete = SyncCompletePayload.toJSON(message.syncComplete);
+    }
+    if (message.syncAck !== void 0) {
+      obj.syncAck = SyncAckPayload.toJSON(message.syncAck);
+    }
+    return obj;
+  },
+  create(base) {
+    return SyncMessage.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSyncMessage();
+    message.hello = object.hello !== void 0 && object.hello !== null ? Hello.fromPartial(object.hello) : void 0;
+    message.syncRequest = object.syncRequest !== void 0 && object.syncRequest !== null ? SyncRequestPayload.fromPartial(object.syncRequest) : void 0;
+    message.syncBatch = object.syncBatch !== void 0 && object.syncBatch !== null ? SyncBatchPayload.fromPartial(object.syncBatch) : void 0;
+    message.syncComplete = object.syncComplete !== void 0 && object.syncComplete !== null ? SyncCompletePayload.fromPartial(object.syncComplete) : void 0;
+    message.syncAck = object.syncAck !== void 0 && object.syncAck !== null ? SyncAckPayload.fromPartial(object.syncAck) : void 0;
+    return message;
+  }
+};
+function createBaseStatement() {
+  return { sql: "", namedParams: {}, positionalParams: [] };
+}
+var Statement = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.sql !== "") {
+      writer.uint32(10).string(message.sql);
+    }
+    globalThis.Object.entries(message.namedParams).forEach(([key, value]) => {
+      Statement_NamedParamsEntry.encode({ key, value }, writer.uint32(18).fork()).join();
+    });
+    for (const v of message.positionalParams) {
+      ColumnValue.encode(v, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStatement();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sql = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = Statement_NamedParamsEntry.decode(reader, reader.uint32());
+          if (entry2.value !== void 0) {
+            message.namedParams[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.positionalParams.push(ColumnValue.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sql: isSet(object.sql) ? globalThis.String(object.sql) : "",
+      namedParams: isObject(object.namedParams) ? globalThis.Object.entries(object.namedParams).reduce(
+        (acc, [key, value]) => {
+          acc[key] = ColumnValue.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : isObject(object.named_params) ? globalThis.Object.entries(object.named_params).reduce(
+        (acc, [key, value]) => {
+          acc[key] = ColumnValue.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      positionalParams: globalThis.Array.isArray(object?.positionalParams) ? object.positionalParams.map((e) => ColumnValue.fromJSON(e)) : globalThis.Array.isArray(object?.positional_params) ? object.positional_params.map((e) => ColumnValue.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sql !== "") {
+      obj.sql = message.sql;
+    }
+    if (message.namedParams) {
+      const entries = globalThis.Object.entries(message.namedParams);
+      if (entries.length > 0) {
+        obj.namedParams = {};
+        entries.forEach(([k, v]) => {
+          obj.namedParams[k] = ColumnValue.toJSON(v);
+        });
+      }
+    }
+    if (message.positionalParams?.length) {
+      obj.positionalParams = message.positionalParams.map((e) => ColumnValue.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return Statement.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStatement();
+    message.sql = object.sql ?? "";
+    message.namedParams = globalThis.Object.entries(object.namedParams ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = ColumnValue.fromPartial(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    message.positionalParams = object.positionalParams?.map((e) => ColumnValue.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseStatement_NamedParamsEntry() {
+  return { key: "", value: void 0 };
+}
+var Statement_NamedParamsEntry = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      ColumnValue.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStatement_NamedParamsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = ColumnValue.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? ColumnValue.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = ColumnValue.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return Statement_NamedParamsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStatement_NamedParamsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? ColumnValue.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseForwardRequest() {
+  return { requestId: "", statements: [], groupId: "", primaryTerm: 0n };
+}
+var ForwardRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    for (const v of message.statements) {
+      Statement.encode(v, writer.uint32(18).fork()).join();
+    }
+    if (message.groupId !== "") {
+      writer.uint32(26).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(32).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseForwardRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.statements.push(Statement.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      statements: globalThis.Array.isArray(object?.statements) ? object.statements.map((e) => Statement.fromJSON(e)) : [],
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.statements?.length) {
+      obj.statements = message.statements.map((e) => Statement.toJSON(e));
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return ForwardRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseForwardRequest();
+    message.requestId = object.requestId ?? "";
+    message.statements = object.statements?.map((e) => Statement.fromPartial(e)) || [];
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+function createBaseStatementResult() {
+  return { changes: 0, lastInsertRowId: 0n };
+}
+var StatementResult = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.changes !== 0) {
+      writer.uint32(8).int32(message.changes);
+    }
+    if (message.lastInsertRowId !== 0n) {
+      if (BigInt.asIntN(64, message.lastInsertRowId) !== message.lastInsertRowId) {
+        throw new globalThis.Error("value provided for field message.lastInsertRowId of type int64 too large");
+      }
+      writer.uint32(16).int64(message.lastInsertRowId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStatementResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.changes = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.lastInsertRowId = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      changes: isSet(object.changes) ? globalThis.Number(object.changes) : 0,
+      lastInsertRowId: isSet(object.lastInsertRowId) ? BigInt(object.lastInsertRowId) : isSet(object.last_insert_row_id) ? BigInt(object.last_insert_row_id) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.changes !== 0) {
+      obj.changes = Math.round(message.changes);
+    }
+    if (message.lastInsertRowId !== 0n) {
+      obj.lastInsertRowId = message.lastInsertRowId.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return StatementResult.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStatementResult();
+    message.changes = object.changes ?? 0;
+    message.lastInsertRowId = object.lastInsertRowId ?? 0n;
+    return message;
+  }
+};
+function createBaseForwardResponse() {
+  return { requestId: "", results: [], error: "", groupId: "", primaryTerm: 0n };
+}
+var ForwardResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.requestId !== "") {
+      writer.uint32(10).string(message.requestId);
+    }
+    for (const v of message.results) {
+      StatementResult.encode(v, writer.uint32(18).fork()).join();
+    }
+    if (message.error !== "") {
+      writer.uint32(26).string(message.error);
+    }
+    if (message.groupId !== "") {
+      writer.uint32(34).string(message.groupId);
+    }
+    if (message.primaryTerm !== 0n) {
+      if (BigInt.asIntN(64, message.primaryTerm) !== message.primaryTerm) {
+        throw new globalThis.Error("value provided for field message.primaryTerm of type int64 too large");
+      }
+      writer.uint32(40).int64(message.primaryTerm);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseForwardResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.requestId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.results.push(StatementResult.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.error = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.groupId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.primaryTerm = reader.int64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : isSet(object.request_id) ? globalThis.String(object.request_id) : "",
+      results: globalThis.Array.isArray(object?.results) ? object.results.map((e) => StatementResult.fromJSON(e)) : [],
+      error: isSet(object.error) ? globalThis.String(object.error) : "",
+      groupId: isSet(object.groupId) ? globalThis.String(object.groupId) : isSet(object.group_id) ? globalThis.String(object.group_id) : "",
+      primaryTerm: isSet(object.primaryTerm) ? BigInt(object.primaryTerm) : isSet(object.primary_term) ? BigInt(object.primary_term) : 0n
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.requestId !== "") {
+      obj.requestId = message.requestId;
+    }
+    if (message.results?.length) {
+      obj.results = message.results.map((e) => StatementResult.toJSON(e));
+    }
+    if (message.error !== "") {
+      obj.error = message.error;
+    }
+    if (message.groupId !== "") {
+      obj.groupId = message.groupId;
+    }
+    if (message.primaryTerm !== 0n) {
+      obj.primaryTerm = message.primaryTerm.toString();
+    }
+    return obj;
+  },
+  create(base) {
+    return ForwardResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseForwardResponse();
+    message.requestId = object.requestId ?? "";
+    message.results = object.results?.map((e) => StatementResult.fromPartial(e)) || [];
+    message.error = object.error ?? "";
+    message.groupId = object.groupId ?? "";
+    message.primaryTerm = object.primaryTerm ?? 0n;
+    return message;
+  }
+};
+var ReplicationService = {
+  replicate: {
+    path: "/sirannon.replication.v1.Replication/Replicate",
+    requestStream: true,
+    responseStream: true,
+    requestSerialize: (value) => Buffer.from(ReplicationMessage.encode(value).finish()),
+    requestDeserialize: (value) => ReplicationMessage.decode(value),
+    responseSerialize: (value) => Buffer.from(ReplicationMessage.encode(value).finish()),
+    responseDeserialize: (value) => ReplicationMessage.decode(value)
+  },
+  sync: {
+    path: "/sirannon.replication.v1.Replication/Sync",
+    requestStream: true,
+    responseStream: true,
+    requestSerialize: (value) => Buffer.from(SyncMessage.encode(value).finish()),
+    requestDeserialize: (value) => SyncMessage.decode(value),
+    responseSerialize: (value) => Buffer.from(SyncMessage.encode(value).finish()),
+    responseDeserialize: (value) => SyncMessage.decode(value)
+  },
+  forward: {
+    path: "/sirannon.replication.v1.Replication/Forward",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(ForwardRequest.encode(value).finish()),
+    requestDeserialize: (value) => ForwardRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(ForwardResponse.encode(value).finish()),
+    responseDeserialize: (value) => ForwardResponse.decode(value)
+  }
+};
+var ReplicationClient = makeGenericClientConstructor(
+  ReplicationService,
+  "sirannon.replication.v1.Replication"
+);
+function bytesFromBase64(b64) {
+  return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+}
+function base64FromBytes(arr) {
+  return globalThis.Buffer.from(arr).toString("base64");
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+function buildServerCreds(options) {
+  if (options.insecure) {
+    return ServerCredentials.createInsecure();
+  }
+  if (!options.tlsCert || !options.tlsKey) {
+    throw new TransportError("TLS certificate and key paths are required when insecure mode is disabled");
+  }
+  const cert = readFileSync(options.tlsCert);
+  const key = readFileSync(options.tlsKey);
+  const ca = options.tlsCaCert ? readFileSync(options.tlsCaCert) : null;
+  return ServerCredentials.createSsl(ca, [{ private_key: key, cert_chain: cert }], ca !== null);
+}
+function buildChannelCreds(options) {
+  if (options.insecure) {
+    return credentials.createInsecure();
+  }
+  if (!options.tlsCert || !options.tlsKey) {
+    throw new TransportError("TLS certificate and key paths are required when insecure mode is disabled");
+  }
+  const cert = readFileSync(options.tlsCert);
+  const key = readFileSync(options.tlsKey);
+  const ca = options.tlsCaCert ? readFileSync(options.tlsCaCert) : null;
+  return credentials.createSsl(ca, key, cert);
+}
+
+// src/transport/grpc/peer-streams.ts
+function registerPeer(connectedPeers, peerConnectedHandler, nodeId, role, metadata = {}) {
+  if (connectedPeers.has(nodeId)) return;
+  const peerInfo = {
+    id: nodeId,
+    groupId: metadata.groupId,
+    role,
+    primaryTerm: metadata.primaryTerm,
+    protocolVersion: metadata.protocolVersion,
+    joinedAt: Date.now(),
+    lastSeenAt: Date.now(),
+    lastAckedSeq: 0n
+  };
+  connectedPeers.set(nodeId, peerInfo);
+  peerConnectedHandler?.(peerInfo);
+}
+function removePeer(connectedPeers, serverPeerStreams, peerDisconnectedHandler, nodeId) {
+  if (!connectedPeers.has(nodeId)) return;
+  connectedPeers.delete(nodeId);
+  serverPeerStreams.delete(nodeId);
+  peerDisconnectedHandler?.(nodeId);
+}
+
+// src/transport/grpc/client-streams.ts
+async function connectToEndpoint(t, endpoint) {
+  const channelCreds = buildChannelCreds(t.options);
+  const clientOpts = {};
+  const client = new ReplicationClient(endpoint, channelCreds, clientOpts);
+  const replicateStream = client.replicate();
+  const syncStream = client.sync();
+  const entry = {
+    client,
+    replicateStream,
+    syncStream
+  };
+  replicateStream.write({
+    hello: {
+      nodeId: t.localNodeId,
+      role: t.localRole,
+      groupId: t.localGroupId ?? "",
+      primaryTerm: t.localPrimaryTerm ?? 0n,
+      protocolVersion: t.localProtocolVersion ?? ""
+    }
+  });
+  syncStream.write({
+    hello: {
+      nodeId: t.localNodeId,
+      role: t.localRole,
+      groupId: t.localGroupId ?? "",
+      primaryTerm: t.localPrimaryTerm ?? 0n,
+      protocolVersion: t.localProtocolVersion ?? ""
+    }
+  });
+  let replicatePeerId = null;
+  replicateStream.on("data", (msg) => {
+    if (replicatePeerId === null) {
+      if (!msg.hello) {
+        replicateStream.cancel();
+        return;
+      }
+      replicatePeerId = msg.hello.nodeId;
+      const peerRole = msg.hello.role;
+      t.clientPeerStreams.set(replicatePeerId, entry);
+      registerPeer(t.connectedPeers, t.peerConnectedHandler, replicatePeerId, peerRole, {
+        groupId: msg.hello.groupId || void 0,
+        primaryTerm: msg.hello.primaryTerm === 0n ? void 0 : msg.hello.primaryTerm,
+        protocolVersion: msg.hello.protocolVersion || void 0
+      });
+      return;
+    }
+    if (msg.batch) {
+      t.batchHandler?.(fromBatchPayload(msg.batch), replicatePeerId).catch(() => {
+      });
+    } else if (msg.ack) {
+      t.ackHandler?.(fromAckPayload(msg.ack), replicatePeerId);
+    }
+  });
+  replicateStream.on("end", () => {
+    detachReplicate(t, replicatePeerId);
+  });
+  replicateStream.on("error", () => {
+    detachReplicate(t, replicatePeerId);
+  });
+  let syncPeerId = null;
+  syncStream.on("data", (msg) => {
+    if (syncPeerId === null) {
+      if (!msg.hello) {
+        syncStream.cancel();
+        return;
+      }
+      syncPeerId = msg.hello.nodeId;
+      return;
+    }
+    if (msg.syncRequest) {
+      t.syncRequestHandler?.(fromSyncRequestPayload(msg.syncRequest), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncBatch) {
+      t.syncBatchHandler?.(fromSyncBatchPayload(msg.syncBatch), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncComplete) {
+      t.syncCompleteHandler?.(fromSyncCompletePayload(msg.syncComplete), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncAck) {
+      t.syncAckHandler?.(fromSyncAckPayload(msg.syncAck), syncPeerId);
+    }
+  });
+  syncStream.on("end", () => {
+    detachSync(t, syncPeerId);
+  });
+  syncStream.on("error", () => {
+    detachSync(t, syncPeerId);
+  });
+}
+function detachReplicate(t, peerId) {
+  if (!peerId) return;
+  const e = t.clientPeerStreams.get(peerId);
+  if (!e) return;
+  e.replicateStream = null;
+  if (!e.syncStream) {
+    t.clientPeerStreams.delete(peerId);
+    removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+  }
+}
+function detachSync(t, peerId) {
+  if (!peerId) return;
+  const e = t.clientPeerStreams.get(peerId);
+  if (!e) return;
+  e.syncStream = null;
+  if (!e.replicateStream) {
+    t.clientPeerStreams.delete(peerId);
+    removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+  }
+}
+
+// src/transport/grpc/options.ts
+var DEFAULT_FORWARD_DEADLINE_MS = 3e4;
+var SERVICE_NAME = "sirannon.replication.v1.Replication";
+async function startServer(t) {
+  const server = new Server();
+  t.server = server;
+  const healthImpl = new HealthImplementation({
+    [SERVICE_NAME]: "SERVING",
+    "": "SERVING"
+  });
+  healthImpl.addToServer(server);
+  t.healthImpl = healthImpl;
+  server.addService(ReplicationService, {
+    replicate: (call) => {
+      handleServerReplicateStream(t, call);
+    },
+    sync: (call) => {
+      handleServerSyncStream(t, call);
+    },
+    forward: (call, callback) => {
+      handleForwardCall(t, call, callback);
+    }
+  });
+  const host = t.options.host ?? "0.0.0.0";
+  const port = t.options.port ?? 0;
+  const bindAddress = `${host}:${port}`;
+  const serverCreds = buildServerCreds(t.options);
+  await new Promise((resolve, reject) => {
+    server.bindAsync(bindAddress, serverCreds, (err, assignedPort) => {
+      if (err) {
+        reject(new TransportError(`Failed to bind gRPC server: ${err.message}`));
+        return;
+      }
+      t.boundPort = assignedPort;
+      resolve();
+    });
+  });
+}
+function handleServerReplicateStream(t, call) {
+  let peerId = null;
+  let helloSent = false;
+  call.on("data", (msg) => {
+    if (peerId === null) {
+      if (!msg.hello) {
+        call.destroy(new Error("First message must be Hello"));
+        return;
+      }
+      if (!t.validateTlsIdentity(call, msg.hello.nodeId)) {
+        call.destroy(new Error(`TLS certificate CN does not match claimed nodeId '${msg.hello.nodeId}'`));
+        return;
+      }
+      peerId = msg.hello.nodeId;
+      const peerRole = msg.hello.role;
+      const existing = t.serverPeerStreams.get(peerId);
+      if (existing?.replicateStream) {
+        existing.replicateStream.end();
+      }
+      const ps = t.serverPeerStreams.get(peerId) ?? {
+        replicateStream: null,
+        syncStream: null
+      };
+      ps.replicateStream = call;
+      t.serverPeerStreams.set(peerId, ps);
+      if (!helloSent) {
+        call.write({
+          hello: {
+            nodeId: t.localNodeId,
+            role: t.localRole,
+            groupId: t.localGroupId ?? "",
+            primaryTerm: t.localPrimaryTerm ?? 0n,
+            protocolVersion: t.localProtocolVersion ?? ""
+          }
+        });
+        helloSent = true;
+      }
+      registerPeer(t.connectedPeers, t.peerConnectedHandler, peerId, peerRole, {
+        groupId: msg.hello.groupId || void 0,
+        primaryTerm: msg.hello.primaryTerm === 0n ? void 0 : msg.hello.primaryTerm,
+        protocolVersion: msg.hello.protocolVersion || void 0
+      });
+      return;
+    }
+    if (msg.batch) {
+      const batch = fromBatchPayload(msg.batch);
+      t.batchHandler?.(batch, peerId).catch(() => {
+      });
+    } else if (msg.ack) {
+      const ack = fromAckPayload(msg.ack);
+      t.ackHandler?.(ack, peerId);
+    }
+  });
+  call.on("end", () => {
+    call.end();
+    if (peerId) {
+      const ps = t.serverPeerStreams.get(peerId);
+      if (ps?.replicateStream === call) {
+        ps.replicateStream = null;
+      }
+      if (!ps?.syncStream) {
+        removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+      }
+    }
+  });
+  call.on("error", () => {
+    if (peerId) {
+      const ps = t.serverPeerStreams.get(peerId);
+      if (ps?.replicateStream === call) {
+        ps.replicateStream = null;
+      }
+      if (!ps?.syncStream) {
+        removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+      }
+    }
+  });
+}
+function handleServerSyncStream(t, call) {
+  let peerId = null;
+  let helloSent = false;
+  call.on("data", (msg) => {
+    if (peerId === null) {
+      if (!msg.hello) {
+        call.destroy(new Error("First message must be Hello"));
+        return;
+      }
+      if (!t.validateTlsIdentity(call, msg.hello.nodeId)) {
+        call.destroy(new Error(`TLS certificate CN does not match claimed nodeId '${msg.hello.nodeId}'`));
+        return;
+      }
+      peerId = msg.hello.nodeId;
+      const peerRole = msg.hello.role;
+      const existing = t.serverPeerStreams.get(peerId);
+      if (existing?.syncStream) {
+        existing.syncStream.end();
+      }
+      const ps = t.serverPeerStreams.get(peerId) ?? {
+        replicateStream: null,
+        syncStream: null
+      };
+      ps.syncStream = call;
+      t.serverPeerStreams.set(peerId, ps);
+      if (!helloSent) {
+        call.write({
+          hello: {
+            nodeId: t.localNodeId,
+            role: t.localRole,
+            groupId: t.localGroupId ?? "",
+            primaryTerm: t.localPrimaryTerm ?? 0n,
+            protocolVersion: t.localProtocolVersion ?? ""
+          }
+        });
+        helloSent = true;
+      }
+      registerPeer(t.connectedPeers, t.peerConnectedHandler, peerId, peerRole, {
+        groupId: msg.hello.groupId || void 0,
+        primaryTerm: msg.hello.primaryTerm === 0n ? void 0 : msg.hello.primaryTerm,
+        protocolVersion: msg.hello.protocolVersion || void 0
+      });
+      return;
+    }
+    if (msg.syncRequest) {
+      t.syncRequestHandler?.(fromSyncRequestPayload(msg.syncRequest), peerId).catch(() => {
+      });
+    } else if (msg.syncBatch) {
+      t.syncBatchHandler?.(fromSyncBatchPayload(msg.syncBatch), peerId).catch(() => {
+      });
+    } else if (msg.syncComplete) {
+      t.syncCompleteHandler?.(fromSyncCompletePayload(msg.syncComplete), peerId).catch(() => {
+      });
+    } else if (msg.syncAck) {
+      t.syncAckHandler?.(fromSyncAckPayload(msg.syncAck), peerId);
+    }
+  });
+  call.on("end", () => {
+    call.end();
+    if (peerId) {
+      const ps = t.serverPeerStreams.get(peerId);
+      if (ps?.syncStream === call) {
+        ps.syncStream = null;
+      }
+      if (!ps?.replicateStream) {
+        removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+      }
+    }
+  });
+  call.on("error", () => {
+    if (peerId) {
+      const ps = t.serverPeerStreams.get(peerId);
+      if (ps?.syncStream === call) {
+        ps.syncStream = null;
+      }
+      if (!ps?.replicateStream) {
+        removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+      }
+    }
+  });
+}
+function handleForwardCall(t, call, callback) {
+  if (!t.forwardHandler) {
+    callback({
+      code: status.UNIMPLEMENTED,
+      message: "Forward handler not registered"
+    });
+    return;
+  }
+  const peerId = t.resolveForwardPeerId(call);
+  if (!peerId) {
+    callback({
+      code: status.UNAUTHENTICATED,
+      message: "Forward request from unidentified peer"
+    });
+    return;
+  }
+  const appReq = fromForwardRequest(call.request);
+  t.forwardHandler(appReq, peerId).then((result) => {
+    callback(null, {
+      requestId: result.requestId,
+      results: result.results.map((r) => ({
+        changes: r.changes,
+        lastInsertRowId: BigInt(typeof r.lastInsertRowId === "string" ? r.lastInsertRowId : r.lastInsertRowId)
+      })),
+      error: "",
+      groupId: result.groupId ?? "",
+      primaryTerm: result.primaryTerm ?? 0n
+    });
+  }).catch((err) => {
+    callback(null, {
+      requestId: call.request.requestId,
+      results: [],
+      error: err.message,
+      groupId: call.request.groupId ?? "",
+      primaryTerm: call.request.primaryTerm ?? 0n
+    });
+  });
+}
+
+// src/transport/grpc/stream-util.ts
+function writeWithBackpressure(stream, message) {
+  return new Promise((resolve, reject) => {
+    const ok = stream.write(message);
+    if (ok) {
+      resolve();
+      return;
+    }
+    const onDrain = () => {
+      stream.removeListener("error", onError);
+      resolve();
+    };
+    const onError = (...args) => {
+      stream.removeListener("drain", onDrain);
+      const err = args[0];
+      reject(err instanceof Error ? err : new Error(String(err)));
+    };
+    stream.once("drain", onDrain);
+    stream.once("error", onError);
+  });
+}
+
+// src/transport/grpc/transport.ts
+var GrpcReplicationTransport = class {
+  options;
+  localNodeId = "";
+  localRole = "replica";
+  localGroupId;
+  localPrimaryTerm;
+  localProtocolVersion;
+  connected = false;
+  server = null;
+  boundPort = 0;
+  healthImpl = null;
+  connectedPeers = /* @__PURE__ */ new Map();
+  serverPeerStreams = /* @__PURE__ */ new Map();
+  clientPeerStreams = /* @__PURE__ */ new Map();
+  batchHandler = null;
+  ackHandler = null;
+  forwardHandler = null;
+  peerConnectedHandler = null;
+  peerDisconnectedHandler = null;
+  syncRequestHandler = null;
+  syncBatchHandler = null;
+  syncCompleteHandler = null;
+  syncAckHandler = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  getPort() {
+    return this.boundPort;
+  }
+  async connect(localNodeId, config) {
+    if (this.connected) {
+      throw new TransportError("Transport is already connected");
+    }
+    if (!localNodeId || typeof localNodeId !== "string") {
+      throw new TransportError("localNodeId must be a non-empty string");
+    }
+    this.localNodeId = localNodeId;
+    this.localRole = config.localRole ?? "replica";
+    this.localGroupId = config.groupId;
+    this.localPrimaryTerm = config.primaryTerm;
+    this.localProtocolVersion = config.protocolVersion;
+    this.connected = true;
+    if (this.localRole === "primary" || config.groupId) {
+      await startServer(this);
+    }
+    if (config.endpoints && config.endpoints.length > 0) {
+      for (const endpoint of config.endpoints) {
+        await connectToEndpoint(this, endpoint);
+      }
+    }
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    this.connected = false;
+    for (const [peerId, entry] of this.clientPeerStreams) {
+      entry.replicateStream?.cancel();
+      entry.syncStream?.cancel();
+      entry.client.close();
+      this.clientPeerStreams.delete(peerId);
+    }
+    for (const [peerId, ps] of this.serverPeerStreams) {
+      ps.replicateStream?.end();
+      ps.syncStream?.end();
+      this.serverPeerStreams.delete(peerId);
+    }
+    const peerIds = [...this.connectedPeers.keys()];
+    this.connectedPeers.clear();
+    for (const peerId of peerIds) {
+      this.peerDisconnectedHandler?.(peerId);
+    }
+    if (this.healthImpl) {
+      this.healthImpl.setStatus(SERVICE_NAME, "NOT_SERVING");
+    }
+    if (this.server) {
+      await new Promise((resolve) => {
+        const srv = this.server;
+        if (!srv) {
+          resolve();
+          return;
+        }
+        srv.tryShutdown((err) => {
+          if (err) {
+            srv.forceShutdown();
+          }
+          resolve();
+        });
+      });
+      this.server = null;
+    }
+  }
+  async send(peerId, batch) {
+    this.ensureConnected();
+    const stream = this.getReplicateWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { batch: toBatchPayload(batch) };
+    await writeWithBackpressure(stream, msg);
+  }
+  async broadcast(batch) {
+    this.ensureConnected();
+    const msg = { batch: toBatchPayload(batch) };
+    const promises = [];
+    for (const [peerId] of this.connectedPeers) {
+      const stream = this.getReplicateWriteStream(peerId);
+      if (stream) {
+        promises.push(writeWithBackpressure(stream, msg));
+      }
+    }
+    await Promise.all(promises);
+  }
+  async sendAck(peerId, ack) {
+    this.ensureConnected();
+    const stream = this.getReplicateWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { ack: toAckPayload(ack) };
+    await writeWithBackpressure(stream, msg);
+  }
+  async forward(peerId, request) {
+    this.ensureConnected();
+    const clientEntry = this.clientPeerStreams.get(peerId);
+    if (!clientEntry) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const protoReq = toForwardRequest(request);
+    const deadlineMs = this.options.forwardDeadlineMs ?? DEFAULT_FORWARD_DEADLINE_MS;
+    const deadline = new Date(Date.now() + deadlineMs);
+    return new Promise((resolve, reject) => {
+      clientEntry.client.forward(
+        protoReq,
+        new Metadata(),
+        { deadline },
+        (err, response) => {
+          if (err) {
+            reject(new TransportError(`Forward RPC failed: ${err.message}`));
+            return;
+          }
+          if (!response) {
+            reject(new TransportError("Forward RPC returned empty response"));
+            return;
+          }
+          if (response.error) {
+            reject(new TransportError(`Forward RPC error: ${response.error}`));
+            return;
+          }
+          resolve({
+            requestId: response.requestId,
+            results: response.results.map((r) => ({
+              changes: r.changes,
+              lastInsertRowId: Number(r.lastInsertRowId)
+            })),
+            groupId: response.groupId || void 0,
+            primaryTerm: response.primaryTerm === 0n ? void 0 : response.primaryTerm
+          });
+        }
+      );
+    });
+  }
+  async requestSync(peerId, request) {
+    this.ensureConnected();
+    const stream = this.getSyncWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { syncRequest: toSyncRequestPayload(request) };
+    await writeWithBackpressure(stream, msg);
+  }
+  async sendSyncBatch(peerId, batch) {
+    this.ensureConnected();
+    const stream = this.getSyncWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { syncBatch: toSyncBatchPayload(batch) };
+    await writeWithBackpressure(stream, msg);
+  }
+  async sendSyncComplete(peerId, complete) {
+    this.ensureConnected();
+    const stream = this.getSyncWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { syncComplete: toSyncCompletePayload(complete) };
+    await writeWithBackpressure(stream, msg);
+  }
+  async sendSyncAck(peerId, ack) {
+    this.ensureConnected();
+    const stream = this.getSyncWriteStream(peerId);
+    if (!stream) {
+      throw new TransportError(`Peer '${peerId}' is not connected`);
+    }
+    const msg = { syncAck: toSyncAckPayload(ack) };
+    await writeWithBackpressure(stream, msg);
+  }
+  onBatchReceived(handler) {
+    this.batchHandler = handler;
+  }
+  onAckReceived(handler) {
+    this.ackHandler = handler;
+  }
+  onForwardReceived(handler) {
+    this.forwardHandler = handler;
+  }
+  onSyncRequested(handler) {
+    this.syncRequestHandler = handler;
+  }
+  onSyncBatchReceived(handler) {
+    this.syncBatchHandler = handler;
+  }
+  onSyncCompleteReceived(handler) {
+    this.syncCompleteHandler = handler;
+  }
+  onSyncAckReceived(handler) {
+    this.syncAckHandler = handler;
+  }
+  onPeerConnected(handler) {
+    this.peerConnectedHandler = handler;
+  }
+  onPeerDisconnected(handler) {
+    this.peerDisconnectedHandler = handler;
+  }
+  peers() {
+    return this.connectedPeers;
+  }
+  extractTlsCN(call) {
+    if (this.options.insecure) return null;
+    if (!this.options.tlsCaCert) return null;
+    const authCtx = call.getAuthContext();
+    if (!authCtx) return null;
+    const peerCert = authCtx.sslPeerCertificate;
+    if (!peerCert) return null;
+    const certCN = peerCert.subject?.CN;
+    if (!certCN) return null;
+    if (Array.isArray(certCN)) return certCN[0] ?? null;
+    return certCN;
+  }
+  validateTlsIdentity(call, claimedNodeId) {
+    if (this.options.insecure) return true;
+    if (!this.options.tlsCaCert) return true;
+    const cn = this.extractTlsCN(call);
+    return cn === claimedNodeId;
+  }
+  resolveForwardPeerId(call) {
+    const cn = this.extractTlsCN(call);
+    if (cn) {
+      return this.connectedPeers.has(cn) ? cn : null;
+    }
+    if (!this.options.insecure) return null;
+    const peerAddr = call.getPeer();
+    for (const [, entry] of this.serverPeerStreams) {
+      if (entry.replicateStream?.getPeer() === peerAddr) {
+        const streamPeerId = this.findPeerIdForStream(entry);
+        if (streamPeerId) return streamPeerId;
+      }
+    }
+    return null;
+  }
+  findPeerIdForStream(entry) {
+    for (const [peerId, ps] of this.serverPeerStreams) {
+      if (ps === entry) return peerId;
+    }
+    return null;
+  }
+  ensureConnected() {
+    if (!this.connected) {
+      throw new TransportError("Transport is not connected");
+    }
+  }
+  getReplicateWriteStream(peerId) {
+    const serverStream = this.serverPeerStreams.get(peerId);
+    if (serverStream?.replicateStream) return serverStream.replicateStream;
+    const clientEntry = this.clientPeerStreams.get(peerId);
+    if (clientEntry?.replicateStream) return clientEntry.replicateStream;
+    return null;
+  }
+  getSyncWriteStream(peerId) {
+    const serverStream = this.serverPeerStreams.get(peerId);
+    if (serverStream?.syncStream) return serverStream.syncStream;
+    const clientEntry = this.clientPeerStreams.get(peerId);
+    if (clientEntry?.syncStream) return clientEntry.syncStream;
+    return null;
+  }
+};
+
+export { GrpcReplicationTransport, fromColumnValue, toColumnValue };