@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/replication/index.mjs

@@ -1,141 +1,20 @@
 import { compatibilityAllowsPromotion } from '../chunk-ER7ODTDA.mjs';
-import { ReplicationError, WriteConcernError, AuthorityError, SyncError, TopologyError, CoordinatorError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError, BatchValidationError } from '../chunk-H5AB6NIR.mjs';
-export { AuthorityError, BatchValidationError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, ReplicationError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-H5AB6NIR.mjs';
-import { Transaction } from '../chunk-TKGHYWQ6.mjs';
-import '../chunk-CW6S3WL5.mjs';
-import { CHANGES_TABLE, APPLIED_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, INTERNAL_TABLE_PREFIX, decodeTaggedValues } from '../chunk-GEZUUIKV.mjs';
-import '../chunk-YPYVQJ4C.mjs';
-import { randomBytes, randomUUID, createHash } from 'crypto';
+import { WriteConcernError, AuthorityError, SyncError, TopologyError, CoordinatorError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError } from '../chunk-O7SLN3GI.mjs';
+export { AuthorityError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-O7SLN3GI.mjs';
+import { LWWResolver, HLC, BatchReader, BatchApplier, StampOps, isWellFormedHlc, Transaction, loadPersistedHlc } from '../chunk-HR5CWTLC.mjs';
+export { HLC, LWWResolver } from '../chunk-HR5CWTLC.mjs';
+import '../chunk-JZGINXTN.mjs';
+import { DumpOps, dumpSchema, tablesInFkOrder } from '../chunk-OQVZBEBY.mjs';
+import { canonicaliseForChecksum, PkResolver, setForeignKeysEnabled, selectMaxAppliedSourceSeqByNode, selectMaxChangeHlc, selectMaxColumnVersionHlc, selectMaxAppliedSourceSeq, upsertPeerAckedSeq, selectPeerAckedSeq, selectMaxChangeSeq, selectMinPeerAckedSeq, upsertSyncTableStatus, upsertSyncMeta, selectSyncMetaRow, selectCompletedSyncTableNames, ensureChangesTable, ensureReplicationStateTables, ensureMetaTable, IDENTIFIER_RE, deleteSyncTableStates, extractDroppedTable, insertDdlChange, prepareInsertAppliedChange } from '../chunk-NVQS53NT.mjs';
+import { ReplicationError, BatchValidationError } from '../chunk-5NOIGN5Y.mjs';
+export { BatchValidationError, ReplicationError } from '../chunk-5NOIGN5Y.mjs';
+import { CHANGES_TABLE, INTERNAL_TABLE_PREFIX } from '../chunk-D7LAYTKN.mjs';
+import '../chunk-GVCNMPOS.mjs';
+import '../chunk-UC3SCMIN.mjs';
 import { EventEmitter } from 'events';
+import { randomBytes, randomUUID, createHash } from 'crypto';
 
-// src/replication/hlc.ts
-var MAX_LOGICAL = 65535;
-var HLC = class _HLC {
-  wallMs;
-  logical;
-  nodeId;
-  constructor(nodeId) {
-    this.nodeId = nodeId;
-    this.wallMs = 0;
-    this.logical = 0;
-  }
-  /** Generate a new HLC timestamp, advancing the clock. */
-  now() {
-    const physicalMs = Date.now();
-    if (physicalMs > this.wallMs) {
-      this.wallMs = physicalMs;
-      this.logical = 0;
-    } else {
-      this.logical += 1;
-      if (this.logical > MAX_LOGICAL) {
-        throw new ReplicationError("HLC logical counter overflow");
-      }
-    }
-    return this.encode(this.wallMs, this.logical, this.nodeId);
-  }
-  /** Merge a remote HLC timestamp into the local clock and return the updated value. */
-  receive(remote) {
-    const r = _HLC.decode(remote);
-    const physicalMs = Date.now();
-    if (physicalMs > this.wallMs && physicalMs > r.wallMs) {
-      this.wallMs = physicalMs;
-      this.logical = 0;
-    } else if (r.wallMs > this.wallMs) {
-      this.wallMs = r.wallMs;
-      this.logical = r.logical + 1;
-    } else if (this.wallMs > r.wallMs) {
-      this.logical += 1;
-    } else {
-      this.logical = Math.max(this.logical, r.logical) + 1;
-    }
-    if (this.logical > MAX_LOGICAL) {
-      throw new ReplicationError("HLC logical counter overflow");
-    }
-    return this.encode(this.wallMs, this.logical, this.nodeId);
-  }
-  /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
-  static compare(a, b) {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  }
-  /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
-  static decode(hlc) {
-    const parts = hlc.split("-");
-    if (parts.length < 3) {
-      throw new ReplicationError(`Invalid HLC format: ${hlc}`);
-    }
-    return {
-      wallMs: Number.parseInt(parts[0], 16),
-      logical: Number.parseInt(parts[1], 16),
-      nodeId: parts.slice(2).join("-")
-    };
-  }
-  encode(wallMs, logical, nodeId) {
-    const wallHex = wallMs.toString(16).padStart(12, "0");
-    const logicalHex = logical.toString(16).padStart(4, "0");
-    return `${wallHex}-${logicalHex}-${nodeId}`;
-  }
-};
-
-// src/replication/log/canonicalise.ts
-function canonicaliseForChecksum(value) {
-  return canonicaliseValue(value);
-}
-function canonicaliseValue(v) {
-  if (v === null || v === void 0) return "null";
-  if (typeof v === "boolean") return v ? "true" : "false";
-  if (typeof v === "string") return JSON.stringify(v);
-  if (typeof v === "bigint") return `{"__sint":"${v.toString()}"}`;
-  if (typeof v === "number") {
-    if (Number.isInteger(v)) return `{"__sint":"${v.toString()}"}`;
-    if (Number.isFinite(v)) return JSON.stringify(v);
-    return "null";
-  }
-  if (typeof v === "object") {
-    if (v instanceof Uint8Array) {
-      const buf = Buffer.isBuffer(v) ? v : Buffer.from(v);
-      return `{"__blob":"${buf.toString("base64")}"}`;
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(v)) {
-      return `{"__blob":"${v.toString("base64")}"}`;
-    }
-    if (Array.isArray(v)) {
-      return `[${v.map(canonicaliseValue).join(",")}]`;
-    }
-    const obj = v;
-    const parts = [];
-    for (const key of Object.keys(obj).sort()) {
-      const val = obj[key];
-      if (val === void 0) continue;
-      parts.push(`${JSON.stringify(key)}:${canonicaliseValue(val)}`);
-    }
-    return `{${parts.join(",")}}`;
-  }
-  return "null";
-}
-
-// src/replication/conflict/lww.ts
-var LWWResolver = class {
-  resolve(ctx) {
-    if (ctx.localHlc === null) {
-      return { action: "accept_remote" };
-    }
-    const cmp = HLC.compare(ctx.remoteHlc, ctx.localHlc);
-    if (cmp > 0) {
-      return { action: "accept_remote" };
-    }
-    if (cmp < 0) {
-      return { action: "keep_local" };
-    }
-    if (ctx.remoteChange.nodeId > (ctx.localChange?.nodeId ?? "")) {
-      return { action: "accept_remote" };
-    }
-    return { action: "keep_local" };
-  }
-};
-
-// src/replication/conflict/field-merge.ts
+// src/core/sync/conflict/field-merge.ts
 var FieldMergeResolver = class {
   getColumnVersions;
   lww = new LWWResolver();
@@ -209,7 +88,7 @@ var FieldMergeResolver = class {
   }
 };
 
-// src/replication/conflict/primary-wins.ts
+// src/core/sync/conflict/primary-wins.ts
 var PrimaryWinsResolver = class {
   primaryNodeId;
   lww = new LWWResolver();
@@ -227,690 +106,6 @@ var PrimaryWinsResolver = class {
   }
 };
 
-// src/replication/engine/constants.ts
-var DEFAULT_BATCH_SIZE = 100;
-var DEFAULT_BATCH_INTERVAL_MS = 100;
-var DEFAULT_MAX_CLOCK_DRIFT_MS = 6e4;
-var DEFAULT_MAX_PENDING_BATCHES = 10;
-var DEFAULT_MAX_BATCH_CHANGES = 1e3;
-var DEFAULT_ACK_TIMEOUT_MS = 5e3;
-var DEFAULT_SYNC_BATCH_SIZE = 1e4;
-var DEFAULT_MAX_CONCURRENT_SYNCS = 2;
-var DEFAULT_MAX_SYNC_DURATION_MS = 18e5;
-var DEFAULT_MAX_SYNC_LAG_BEFORE_READY = 100;
-var DEFAULT_SYNC_ACK_TIMEOUT_MS = 3e4;
-var DEFAULT_CATCH_UP_DEADLINE_MS = 6e5;
-var DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
-var SAFE_SQL_PREFIX_RE = /^\s*(INSERT|UPDATE|DELETE|SELECT|CREATE\s+TABLE|ALTER\s+TABLE|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
-var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var DDL_DENY_RE = /\b(load_extension|ATTACH|randomblob|zeroblob|writefile|readfile|fts3_tokenizer)\b/i;
-var DROP_TABLE_RE = /^\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"?([A-Za-z_][A-Za-z0-9_]*)"?\s*;?\s*$/i;
-function extractDroppedTable(sql) {
-  const m = DROP_TABLE_RE.exec(sql);
-  return m?.[1] ?? null;
-}
-var SYNC_SAFE_DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
-function isSyncSafeDdl(sql) {
-  if (!SYNC_SAFE_DDL_PREFIX_RE.test(sql)) return false;
-  if (sql.includes(";")) return false;
-  if (/\bAS\s+SELECT\b/i.test(sql)) return false;
-  if (DDL_DENY_RE.test(sql)) return false;
-  const body = sql.replace(SYNC_SAFE_DDL_PREFIX_RE, "");
-  if (/\bSELECT\b/i.test(body)) return false;
-  return true;
-}
-var BatchReader = class {
-  constructor(conn, localNodeId, hlc, changesTable, pkResolver) {
-    this.conn = conn;
-    this.localNodeId = localNodeId;
-    this.hlc = hlc;
-    this.changesTable = changesTable;
-    this.pkResolver = pkResolver;
-  }
-  async readBatch(afterSeq, batchSize) {
-    const stmt = await this.conn.prepare(
-      `SELECT seq, table_name, operation, row_id, changed_at, old_data, new_data, node_id, tx_id, hlc
-       FROM "${this.changesTable}"
-       WHERE seq > ? AND node_id = ?
-       ORDER BY seq ASC
-       LIMIT ?`
-    );
-    const rows = await stmt.all(afterSeq.toString(), this.localNodeId, batchSize);
-    if (rows.length === 0) {
-      return null;
-    }
-    const changes = [];
-    let minHlc = rows[0].hlc;
-    let maxHlc = rows[0].hlc;
-    for (const row of rows) {
-      const operation = row.operation.toLowerCase();
-      const isDdl = operation === "ddl";
-      const rawNewData = row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : null;
-      const rawOldData = row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : null;
-      let ddlStatement;
-      let newData = rawNewData;
-      let oldData = rawOldData;
-      if (isDdl) {
-        const candidate = rawNewData?.ddlStatement;
-        if (typeof candidate === "string") {
-          ddlStatement = candidate;
-        }
-        newData = null;
-        oldData = null;
-      }
-      const pkColumns = isDdl ? [] : await this.pkResolver.forTable(row.table_name);
-      const primaryKey = {};
-      if (!isDdl) {
-        const sourceData = rawNewData ?? rawOldData ?? {};
-        for (const col of pkColumns) {
-          if (col in sourceData) {
-            primaryKey[col] = sourceData[col];
-          }
-        }
-      }
-      const change = {
-        table: row.table_name,
-        operation,
-        rowId: String(row.row_id),
-        primaryKey,
-        hlc: row.hlc,
-        txId: row.tx_id,
-        nodeId: row.node_id,
-        newData,
-        oldData
-      };
-      if (ddlStatement !== void 0) {
-        change.ddlStatement = ddlStatement;
-      }
-      changes.push(change);
-      if (HLC.compare(row.hlc, minHlc) < 0) {
-        minHlc = row.hlc;
-      }
-      if (HLC.compare(row.hlc, maxHlc) > 0) {
-        maxHlc = row.hlc;
-      }
-    }
-    const fromSeq = BigInt(rows[0].seq);
-    const toSeq = BigInt(rows[rows.length - 1].seq);
-    const checksum = computeChecksum(changes);
-    return {
-      sourceNodeId: this.localNodeId,
-      batchId: `${this.localNodeId}-${fromSeq}-${toSeq}`,
-      fromSeq,
-      toSeq,
-      hlcRange: { min: minHlc, max: maxHlc },
-      changes,
-      checksum
-    };
-  }
-  async stampChanges(tx, afterSeq, txId) {
-    const hlcValue = this.hlc.now();
-    const stmt = await tx.prepare(
-      `UPDATE "${this.changesTable}" SET node_id = ?, tx_id = ?, hlc = ? WHERE seq > ? AND node_id = ''`
-    );
-    await stmt.run(this.localNodeId, txId, hlcValue, afterSeq.toString());
-  }
-  async updateColumnVersions(tx, afterSeq) {
-    const selectStmt = await tx.prepare(
-      `SELECT seq, table_name, operation, row_id, old_data, new_data, hlc, node_id
-       FROM "${this.changesTable}"
-       WHERE seq > ? AND node_id = ?
-       ORDER BY seq ASC`
-    );
-    const rows = await selectStmt.all(afterSeq.toString(), this.localNodeId);
-    for (const row of rows) {
-      if (row.operation === "DELETE") {
-        const delStmt = await tx.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`);
-        await delStmt.run(row.table_name, String(row.row_id));
-        continue;
-      }
-      const oldData = row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : {};
-      const newData = row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {};
-      const changedCols = [];
-      if (row.operation === "INSERT") {
-        for (const key of Object.keys(newData)) {
-          changedCols.push(key);
-        }
-      } else {
-        for (const key of Object.keys(newData)) {
-          if (canonicaliseForChecksum(newData[key]) !== canonicaliseForChecksum(oldData[key])) {
-            changedCols.push(key);
-          }
-        }
-      }
-      const upsertStmt = await tx.prepare(
-        `INSERT INTO ${COLUMN_VERSIONS_TABLE} (table_name, row_id, column_name, hlc, node_id)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(table_name, row_id, column_name)
-         DO UPDATE SET hlc = excluded.hlc, node_id = excluded.node_id`
-      );
-      for (const col of changedCols) {
-        await upsertStmt.run(row.table_name, String(row.row_id), col, row.hlc, row.node_id);
-      }
-    }
-  }
-};
-function computeChecksum(changes) {
-  const hash = createHash("sha256");
-  hash.update(canonicaliseForChecksum(changes));
-  return hash.digest("hex");
-}
-
-// src/replication/log/validators.ts
-var IDENTIFIER_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var SAFE_DDL_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
-var DDL_DENY_RE2 = /\b(load_extension|ATTACH|randomblob|zeroblob|writefile|readfile|fts3_tokenizer)\b/i;
-function validateIdentifier(name) {
-  return IDENTIFIER_RE2.test(name);
-}
-function validateDdlSafety(sql) {
-  if (!SAFE_DDL_RE.test(sql)) return false;
-  if (sql.includes(";")) return false;
-  if (/\bAS\s+SELECT\b/i.test(sql)) return false;
-  if (DDL_DENY_RE2.test(sql)) return false;
-  const body = sql.replace(SAFE_DDL_RE, "");
-  if (/\bSELECT\b/i.test(body)) return false;
-  return true;
-}
-
-// src/replication/log/batch-applier.ts
-var BatchApplier = class {
-  constructor(conn, localNodeId, hlc, pkResolver, getLastAppliedSeq, tracker) {
-    this.conn = conn;
-    this.localNodeId = localNodeId;
-    this.hlc = hlc;
-    this.pkResolver = pkResolver;
-    this.getLastAppliedSeq = getLastAppliedSeq;
-    this.tracker = tracker;
-  }
-  async applyBatch(batch, resolver) {
-    const expectedChecksum = computeChecksum(batch.changes);
-    if (batch.checksum !== expectedChecksum) {
-      throw new BatchValidationError(`Checksum mismatch: expected ${expectedChecksum}, got ${batch.checksum}`);
-    }
-    for (const change of batch.changes) {
-      if (change.operation !== "ddl") {
-        if (!IDENTIFIER_RE2.test(change.table)) {
-          throw new BatchValidationError(`Invalid table name: ${change.table}`);
-        }
-      }
-    }
-    const lastApplied = await this.getLastAppliedSeq(batch.sourceNodeId);
-    if (batch.toSeq <= lastApplied) {
-      return { applied: 0, skipped: batch.changes.length, conflicts: 0, droppedTables: [] };
-    }
-    const needsPartialDedup = batch.fromSeq <= lastApplied;
-    let appliedSeqSet = null;
-    if (needsPartialDedup) {
-      appliedSeqSet = /* @__PURE__ */ new Set();
-      const checkStmt = await this.conn.prepare(
-        `SELECT source_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ? AND source_seq >= ? AND source_seq <= ?`
-      );
-      const applied2 = await checkStmt.all(
-        batch.sourceNodeId,
-        batch.fromSeq.toString(),
-        batch.toSeq.toString()
-      );
-      for (const row of applied2) {
-        appliedSeqSet.add(String(row.source_seq));
-      }
-    }
-    let applied = 0;
-    let skipped = 0;
-    let conflicts = 0;
-    const droppedTables = [];
-    const changesByTx = /* @__PURE__ */ new Map();
-    for (const change of batch.changes) {
-      const txGroup = changesByTx.get(change.txId);
-      if (txGroup) {
-        txGroup.push(change);
-      } else {
-        changesByTx.set(change.txId, [change]);
-      }
-    }
-    for (const [_txId, txChanges] of changesByTx) {
-      const txDroppedTables = [];
-      const result = await this.conn.transaction(async (tx) => {
-        let txApplied = 0;
-        let txSkipped = 0;
-        let txConflicts = 0;
-        const ddlChanges = txChanges.filter((c) => c.operation === "ddl");
-        const dataChanges = txChanges.filter((c) => c.operation !== "ddl");
-        for (const ddl of ddlChanges) {
-          const ddlSql = ddl.ddlStatement;
-          if (!ddlSql || !validateDdlSafety(ddlSql)) {
-            throw new BatchValidationError(`Unsafe or missing DDL statement: ${ddlSql ?? "none"}`);
-          }
-          await tx.exec(ddlSql);
-          const droppedTable = extractDroppedTable(ddlSql);
-          if (droppedTable !== null) {
-            txDroppedTables.push(droppedTable);
-          }
-          if (this.tracker) {
-            await this.tracker.refreshAllTriggersUsingConnection(tx);
-          }
-          txApplied += 1;
-        }
-        for (const change of dataChanges) {
-          const existingRow = await this.findExistingRow(tx, change);
-          if (existingRow === void 0) {
-            if (change.operation === "insert" && change.newData) {
-              await this.insertRow(tx, change);
-              await this.recordColumnVersions(tx, change, change.newData);
-              txApplied += 1;
-            } else if (change.operation === "delete") {
-              txApplied += 1;
-            } else {
-              txSkipped += 1;
-            }
-          } else {
-            txConflicts += 1;
-            const localHlc = await this.getLocalHlcForRow(tx, change.table, change.rowId);
-            const localChange = {
-              table: change.table,
-              operation: "update",
-              rowId: change.rowId,
-              primaryKey: change.primaryKey,
-              hlc: localHlc ?? "",
-              txId: "",
-              nodeId: this.localNodeId,
-              newData: existingRow,
-              oldData: null
-            };
-            const changeResolver = typeof resolver === "function" ? resolver(change.table) : resolver;
-            const resolution = await changeResolver.resolve({
-              table: change.table,
-              rowId: change.rowId,
-              localChange,
-              remoteChange: change,
-              localHlc,
-              remoteHlc: change.hlc
-            });
-            if (resolution.action === "accept_remote") {
-              await this.applyRemoteChange(tx, change);
-              await this.recordColumnVersions(tx, change, change.newData);
-              txApplied += 1;
-            } else if (resolution.action === "merge" && resolution.mergedData) {
-              await this.applyMergedData(tx, change, resolution.mergedData);
-              await this.recordColumnVersions(tx, change, resolution.mergedData);
-              txApplied += 1;
-            } else {
-              txSkipped += 1;
-            }
-          }
-        }
-        return { txApplied, txSkipped, txConflicts };
-      });
-      applied += result.txApplied;
-      skipped += result.txSkipped;
-      conflicts += result.txConflicts;
-      if (txDroppedTables.length > 0) {
-        droppedTables.push(...txDroppedTables);
-      }
-    }
-    const recordStmt = await this.conn.prepare(
-      `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
-    );
-    const nowSec = Date.now() / 1e3;
-    for (let seq = batch.fromSeq; seq <= batch.toSeq; seq += 1n) {
-      if (appliedSeqSet?.has(seq.toString())) continue;
-      await recordStmt.run(batch.sourceNodeId, seq.toString(), nowSec);
-    }
-    try {
-      this.hlc.receive(batch.hlcRange.max);
-    } catch {
-    }
-    return { applied, skipped, conflicts, droppedTables };
-  }
-  async findExistingRow(tx, change) {
-    if (!IDENTIFIER_RE2.test(change.table)) return void 0;
-    const pkColumns = await this.pkResolver.forTable(change.table);
-    const result = await findRowByPk(tx, change.table, pkColumns, change.newData ?? change.oldData ?? {});
-    if (result) return result;
-    if (change.operation === "update" && change.oldData) {
-      return findRowByPk(tx, change.table, pkColumns, change.oldData);
-    }
-    return void 0;
-  }
-  async getLocalHlcForRow(tx, table, rowId) {
-    const stmt = await tx.prepare(
-      `SELECT MAX(hlc) as max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`
-    );
-    const row = await stmt.get(table, rowId);
-    return row?.max_hlc ?? null;
-  }
-  async insertRow(tx, change) {
-    if (!change.newData) return;
-    const columns = Object.keys(change.newData).filter(validateIdentifier);
-    if (columns.length === 0) return;
-    const placeholders = columns.map(() => "?").join(", ");
-    const colNames = columns.map((c) => `"${c}"`).join(", ");
-    const values = columns.map((c) => change.newData?.[c]);
-    const stmt = await tx.prepare(`INSERT INTO "${change.table}" (${colNames}) VALUES (${placeholders})`);
-    await stmt.run(...values);
-  }
-  async applyRemoteChange(tx, change) {
-    if (change.operation === "delete") {
-      await this.deleteRow(tx, change);
-      return;
-    }
-    if (!change.newData) return;
-    const pkColumns = await this.pkResolver.forTable(change.table);
-    const sourceData = change.newData;
-    const wherePkSource = change.oldData ?? sourceData;
-    const setClauses = [];
-    const setValues = [];
-    const whereConditions = [];
-    const whereValues = [];
-    const pkSet = new Set(pkColumns);
-    for (const [col, val] of Object.entries(sourceData)) {
-      if (!validateIdentifier(col)) continue;
-      if (pkSet.has(col)) continue;
-      setClauses.push(`"${col}" = ?`);
-      setValues.push(val);
-    }
-    for (const col of pkColumns) {
-      if (!validateIdentifier(col)) continue;
-      whereConditions.push(`"${col}" = ?`);
-      whereValues.push(wherePkSource[col]);
-    }
-    if (setClauses.length === 0 || whereConditions.length === 0) return;
-    const stmt = await tx.prepare(
-      `UPDATE "${change.table}" SET ${setClauses.join(", ")} WHERE ${whereConditions.join(" AND ")}`
-    );
-    await stmt.run(...setValues, ...whereValues);
-  }
-  async applyMergedData(tx, change, mergedData) {
-    const pkColumns = await this.pkResolver.forTable(change.table);
-    const sourceData = change.newData ?? change.oldData ?? {};
-    const setClauses = [];
-    const setValues = [];
-    const whereConditions = [];
-    const whereValues = [];
-    for (const [col, val] of Object.entries(mergedData)) {
-      if (!validateIdentifier(col)) continue;
-      if (!pkColumns.includes(col)) {
-        setClauses.push(`"${col}" = ?`);
-        setValues.push(val);
-      }
-    }
-    for (const col of pkColumns) {
-      if (!validateIdentifier(col)) continue;
-      whereConditions.push(`"${col}" = ?`);
-      whereValues.push(sourceData[col]);
-    }
-    if (setClauses.length === 0 || whereConditions.length === 0) return;
-    const stmt = await tx.prepare(
-      `UPDATE "${change.table}" SET ${setClauses.join(", ")} WHERE ${whereConditions.join(" AND ")}`
-    );
-    await stmt.run(...setValues, ...whereValues);
-  }
-  async deleteRow(tx, change) {
-    const pkColumns = await this.pkResolver.forTable(change.table);
-    const sourceData = change.oldData ?? change.newData ?? {};
-    const conditions = [];
-    const values = [];
-    for (const col of pkColumns) {
-      if (!validateIdentifier(col)) continue;
-      conditions.push(`"${col}" = ?`);
-      values.push(sourceData[col]);
-    }
-    if (conditions.length === 0) return;
-    const stmt = await tx.prepare(`DELETE FROM "${change.table}" WHERE ${conditions.join(" AND ")}`);
-    await stmt.run(...values);
-  }
-  async recordColumnVersions(tx, change, data) {
-    if (change.operation === "delete") {
-      const delStmt = await tx.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`);
-      await delStmt.run(change.table, change.rowId);
-      return;
-    }
-    if (!data) return;
-    const upsertStmt = await tx.prepare(
-      `INSERT INTO ${COLUMN_VERSIONS_TABLE} (table_name, row_id, column_name, hlc, node_id)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(table_name, row_id, column_name)
-       DO UPDATE SET hlc = excluded.hlc, node_id = excluded.node_id`
-    );
-    for (const col of Object.keys(data)) {
-      if (!validateIdentifier(col)) continue;
-      await upsertStmt.run(change.table, change.rowId, col, change.hlc, change.nodeId);
-    }
-  }
-};
-async function findRowByPk(tx, table, pkColumns, sourceData) {
-  const conditions = [];
-  const values = [];
-  for (const col of pkColumns) {
-    if (!validateIdentifier(col)) return void 0;
-    if (!(col in sourceData)) return void 0;
-    conditions.push(`"${col}" = ?`);
-    values.push(sourceData[col]);
-  }
-  if (conditions.length === 0) return void 0;
-  const stmt = await tx.prepare(`SELECT * FROM "${table}" WHERE ${conditions.join(" AND ")} LIMIT 1`);
-  return stmt.get(...values);
-}
-var DumpOps = class {
-  constructor(conn, localNodeId, hlc, pkResolver) {
-    this.conn = conn;
-    this.localNodeId = localNodeId;
-    this.hlc = hlc;
-    this.pkResolver = pkResolver;
-  }
-  async *dumpTable(table, batchSize) {
-    if (!IDENTIFIER_RE2.test(table)) {
-      throw new ReplicationError(`Invalid table name: ${table}`);
-    }
-    const countStmt = await this.conn.prepare(`SELECT COUNT(*) as cnt FROM "${table}"`);
-    const countRow = await countStmt.get();
-    const total = countRow?.cnt ?? 0;
-    if (total === 0) return;
-    const pkColumns = await this.pkResolver.forTable(table);
-    let offset = 0;
-    let batchNum = 0;
-    const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
-    while (offset < total) {
-      const selectSql = needsRowid ? `SELECT rowid, * FROM "${table}" LIMIT ? OFFSET ?` : `SELECT * FROM "${table}" LIMIT ? OFFSET ?`;
-      const selectStmt = await this.conn.prepare(selectSql);
-      const rows = await selectStmt.all(batchSize, offset);
-      if (rows.length === 0) break;
-      const changes = [];
-      const hlcValue = this.hlc.now();
-      for (const row of rows) {
-        const primaryKey = {};
-        for (const col of pkColumns) {
-          if (col in row) {
-            primaryKey[col] = row[col];
-          }
-        }
-        const rowId = pkColumns.map((col) => String(row[col] ?? "")).join("-");
-        changes.push({
-          table,
-          operation: "insert",
-          rowId,
-          primaryKey,
-          hlc: hlcValue,
-          txId: `dump-${table}-${batchNum}`,
-          nodeId: this.localNodeId,
-          newData: row,
-          oldData: null
-        });
-      }
-      const checksum = computeChecksum(changes);
-      const dumpEpoch = BigInt(Date.now()) * 1000000n;
-      const fromSeq = dumpEpoch + BigInt(offset);
-      const toSeq = dumpEpoch + BigInt(offset + rows.length - 1);
-      const dumpNodeId = `dump-${this.localNodeId}`;
-      yield {
-        sourceNodeId: dumpNodeId,
-        batchId: `dump-${table}-${batchNum}`,
-        fromSeq,
-        toSeq,
-        hlcRange: { min: hlcValue, max: hlcValue },
-        changes,
-        checksum
-      };
-      offset += rows.length;
-      batchNum += 1;
-    }
-  }
-  async *dumpTableOnConnection(conn, table, batchSize) {
-    if (!IDENTIFIER_RE2.test(table)) {
-      throw new ReplicationError(`Invalid table name: ${table}`);
-    }
-    const pkColumns = await this.pkResolver.forTableOnConnection(conn, table);
-    const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
-    let lastPkValues = null;
-    let done = false;
-    while (!done) {
-      let selectSql;
-      const params = [];
-      if (lastPkValues === null) {
-        selectSql = needsRowid ? `SELECT rowid, * FROM "${table}" ORDER BY rowid LIMIT ?` : `SELECT * FROM "${table}" ORDER BY ${pkColumns.map((c) => `"${c}"`).join(", ")} LIMIT ?`;
-        params.push(batchSize);
-      } else if (needsRowid) {
-        selectSql = `SELECT rowid, * FROM "${table}" WHERE rowid > ? ORDER BY rowid LIMIT ?`;
-        params.push(lastPkValues[0], batchSize);
-      } else if (pkColumns.length === 1) {
-        selectSql = `SELECT * FROM "${table}" WHERE "${pkColumns[0]}" > ? ORDER BY "${pkColumns[0]}" LIMIT ?`;
-        params.push(lastPkValues[0], batchSize);
-      } else {
-        const colList = pkColumns.map((c) => `"${c}"`).join(", ");
-        const placeholders = pkColumns.map(() => "?").join(", ");
-        selectSql = `SELECT * FROM "${table}" WHERE (${colList}) > (${placeholders}) ORDER BY ${colList} LIMIT ?`;
-        params.push(...lastPkValues, batchSize);
-      }
-      const stmt = await conn.prepare(selectSql);
-      const rows = await stmt.all(...params);
-      if (rows.length === 0) {
-        break;
-      }
-      const lastRow = rows[rows.length - 1];
-      lastPkValues = pkColumns.map((col) => lastRow[col]);
-      let isLast = rows.length < batchSize;
-      if (!isLast) {
-        let peekSql;
-        const peekParams = [];
-        if (needsRowid) {
-          peekSql = `SELECT 1 FROM "${table}" WHERE rowid > ? LIMIT 1`;
-          peekParams.push(lastPkValues[0]);
-        } else if (pkColumns.length === 1) {
-          peekSql = `SELECT 1 FROM "${table}" WHERE "${pkColumns[0]}" > ? LIMIT 1`;
-          peekParams.push(lastPkValues[0]);
-        } else {
-          const colList = pkColumns.map((c) => `"${c}"`).join(", ");
-          const placeholders = pkColumns.map(() => "?").join(", ");
-          peekSql = `SELECT 1 FROM "${table}" WHERE (${colList}) > (${placeholders}) LIMIT 1`;
-          peekParams.push(...lastPkValues);
-        }
-        const peekStmt = await conn.prepare(peekSql);
-        const peekRow = await peekStmt.get(...peekParams);
-        if (!peekRow) {
-          isLast = true;
-        }
-      }
-      done = isLast;
-      const checksum = createHash("sha256").update(canonicaliseForChecksum(rows)).digest("hex");
-      yield { rows, checksum, isLast };
-    }
-  }
-  async generateManifest(conn, table) {
-    if (!IDENTIFIER_RE2.test(table)) {
-      throw new ReplicationError(`Invalid table name: ${table}`);
-    }
-    const countStmt = await conn.prepare(`SELECT COUNT(*) as cnt FROM "${table}"`);
-    const countRow = await countStmt.get();
-    const rowCount = countRow?.cnt ?? 0;
-    const hash = createHash("sha256");
-    const pkColumns = await this.pkResolver.forTableOnConnection(conn, table);
-    const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
-    let lastPkValues = null;
-    const PK_BATCH_SIZE = 1e4;
-    let hasRows = true;
-    while (hasRows) {
-      let selectSql;
-      const params = [];
-      if (needsRowid) {
-        if (lastPkValues === null) {
-          selectSql = `SELECT rowid FROM "${table}" ORDER BY rowid LIMIT ?`;
-        } else {
-          selectSql = `SELECT rowid FROM "${table}" WHERE rowid > ? ORDER BY rowid LIMIT ?`;
-          params.push(lastPkValues[0]);
-        }
-      } else if (pkColumns.length === 1) {
-        const col = pkColumns[0];
-        if (lastPkValues === null) {
-          selectSql = `SELECT "${col}" FROM "${table}" ORDER BY "${col}" LIMIT ?`;
-        } else {
-          selectSql = `SELECT "${col}" FROM "${table}" WHERE "${col}" > ? ORDER BY "${col}" LIMIT ?`;
-          params.push(lastPkValues[0]);
-        }
-      } else {
-        const colList = pkColumns.map((c) => `"${c}"`).join(", ");
-        if (lastPkValues === null) {
-          selectSql = `SELECT ${colList} FROM "${table}" ORDER BY ${colList} LIMIT ?`;
-        } else {
-          const placeholders = pkColumns.map(() => "?").join(", ");
-          selectSql = `SELECT ${colList} FROM "${table}" WHERE (${colList}) > (${placeholders}) ORDER BY ${colList} LIMIT ?`;
-          params.push(...lastPkValues);
-        }
-      }
-      params.push(PK_BATCH_SIZE);
-      const stmt = await conn.prepare(selectSql);
-      const rows = await stmt.all(...params);
-      if (rows.length === 0) {
-        hasRows = false;
-        break;
-      }
-      for (const row of rows) {
-        const pkVal = pkColumns.map((col) => String(row[col] ?? "")).join("-");
-        hash.update(pkVal);
-      }
-      if (rows.length < PK_BATCH_SIZE) {
-        hasRows = false;
-      } else {
-        const lastRow = rows[rows.length - 1];
-        lastPkValues = pkColumns.map((col) => lastRow[col]);
-      }
-    }
-    return { table, rowCount, pkHash: hash.digest("hex") };
-  }
-  async verifyManifest(manifest) {
-    const local = await this.generateManifest(this.conn, manifest.table);
-    return local.rowCount === manifest.rowCount && local.pkHash === manifest.pkHash;
-  }
-};
-
-// src/replication/log/pk.ts
-var PkResolver = class {
-  constructor(conn) {
-    this.conn = conn;
-  }
-  cache = /* @__PURE__ */ new Map();
-  async forTable(table) {
-    const cached = this.cache.get(table);
-    if (cached) return cached;
-    const stmt = await this.conn.prepare(`PRAGMA table_info("${table}")`);
-    const info = await stmt.all();
-    const pkCols = info.filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
-    if (pkCols.length === 0) {
-      pkCols.push("rowid");
-    }
-    this.cache.set(table, pkCols);
-    return pkCols;
-  }
-  async forTableOnConnection(conn, table) {
-    const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
-    const info = await stmt.all();
-    const pkCols = info.filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
-    if (pkCols.length === 0) {
-      pkCols.push("rowid");
-    }
-    return pkCols;
-  }
-};
-
 // src/replication/log/schema.ts
 var SchemaOps = class {
   constructor(conn, changesTable) {
@@ -918,150 +113,23 @@ var SchemaOps = class {
     this.changesTable = changesTable;
   }
   async ensureReplicationTables() {
-    await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
-	seq INTEGER PRIMARY KEY AUTOINCREMENT,
-	table_name TEXT NOT NULL,
-	operation TEXT NOT NULL,
-	row_id TEXT NOT NULL,
-	changed_at REAL NOT NULL DEFAULT (unixepoch('subsec')),
-	old_data TEXT,
-	new_data TEXT,
-	node_id TEXT NOT NULL DEFAULT '',
-	tx_id TEXT NOT NULL DEFAULT '',
-	hlc TEXT NOT NULL DEFAULT ''
-)`);
-    await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS ${PEER_STATE_TABLE} (
-	peer_node_id TEXT PRIMARY KEY,
-	last_acked_seq INTEGER NOT NULL DEFAULT 0,
-	last_received_hlc TEXT NOT NULL DEFAULT '',
-	updated_at REAL NOT NULL
-)`);
-    await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS ${APPLIED_CHANGES_TABLE} (
-	source_node_id TEXT NOT NULL,
-	source_seq INTEGER NOT NULL,
-	applied_at REAL NOT NULL,
-	PRIMARY KEY (source_node_id, source_seq)
-)`);
-    await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS ${COLUMN_VERSIONS_TABLE} (
-	table_name TEXT NOT NULL,
-	row_id TEXT NOT NULL,
-	column_name TEXT NOT NULL,
-	hlc TEXT NOT NULL,
-	node_id TEXT NOT NULL,
-	PRIMARY KEY (table_name, row_id, column_name)
-)`);
-    await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS ${SYNC_STATE_TABLE} (
-	table_name TEXT PRIMARY KEY,
-	status TEXT NOT NULL DEFAULT 'pending',
-	row_count INTEGER NOT NULL DEFAULT 0,
-	pk_hash TEXT NOT NULL DEFAULT '',
-	snapshot_seq INTEGER,
-	source_peer_id TEXT,
-	started_at REAL,
-	completed_at REAL,
-	request_id TEXT
-)`);
+    await ensureChangesTable(this.conn, this.changesTable);
+    await ensureReplicationStateTables(this.conn);
+    await ensureMetaTable(this.conn);
   }
   async dumpSchema(conn, excludePrefix = INTERNAL_TABLE_PREFIX) {
-    const stmt = await conn.prepare(
-      `SELECT type, name, sql FROM sqlite_master
-       WHERE type IN ('table', 'index') AND name NOT LIKE ? AND name NOT LIKE 'sqlite_%' AND sql IS NOT NULL`
-    );
-    const rows = await stmt.all(`${excludePrefix}%`);
-    const filtered = rows.filter((row) => {
-      if (row.name.startsWith(excludePrefix)) return false;
-      if (row.name.startsWith("sqlite_")) return false;
-      return validateDdlSafety(row.sql);
-    });
-    const tables = [];
-    const indexes = [];
-    for (const row of filtered) {
-      if (row.type === "table") {
-        tables.push({ name: row.name, sql: row.sql });
-      } else {
-        indexes.push({ sql: row.sql });
-      }
-    }
-    const tableOrder = await this.getTablesInFkOrder(conn);
-    const orderMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < tableOrder.length; i++) {
-      orderMap.set(tableOrder[i], i);
-    }
-    tables.sort((a, b) => (orderMap.get(a.name) ?? 999) - (orderMap.get(b.name) ?? 999));
-    const result = [];
-    for (const t of tables) {
-      result.push(t.sql);
-    }
-    for (const idx of indexes) {
-      result.push(idx.sql);
-    }
-    return result;
+    return dumpSchema(conn, excludePrefix);
   }
   async getTablesInFkOrder(conn) {
-    const stmt = await conn.prepare(
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE '${INTERNAL_TABLE_PREFIX}%' AND name NOT LIKE 'sqlite_%'`
-    );
-    const tableRows = await stmt.all();
-    const tableNames = tableRows.map((r) => r.name);
-    const adjacency = /* @__PURE__ */ new Map();
-    const inDegree = /* @__PURE__ */ new Map();
-    for (const name of tableNames) {
-      adjacency.set(name, /* @__PURE__ */ new Set());
-      inDegree.set(name, 0);
-    }
-    for (const name of tableNames) {
-      const fkStmt = await conn.prepare(`PRAGMA foreign_key_list("${name}")`);
-      const fks = await fkStmt.all();
-      for (const fk of fks) {
-        if (tableNames.includes(fk.table) && fk.table !== name) {
-          const deps = adjacency.get(fk.table);
-          if (deps && !deps.has(name)) {
-            deps.add(name);
-            inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
-          }
-        }
-      }
-    }
-    const queue = [];
-    for (const name of tableNames) {
-      if ((inDegree.get(name) ?? 0) === 0) {
-        queue.push(name);
-      }
-    }
-    const sorted = [];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current === void 0) break;
-      sorted.push(current);
-      const deps = adjacency.get(current);
-      if (deps) {
-        for (const dep of deps) {
-          const newDeg = (inDegree.get(dep) ?? 1) - 1;
-          inDegree.set(dep, newDeg);
-          if (newDeg === 0) {
-            queue.push(dep);
-          }
-        }
-      }
-    }
-    if (sorted.length < tableNames.length) {
-      const remaining = tableNames.filter((n) => !sorted.includes(n)).sort();
-      sorted.push(...remaining);
-    }
-    return sorted;
+    return tablesInFkOrder(conn);
   }
   async wipeTables(conn, tables, tracker) {
     for (const table of tables) {
-      if (!IDENTIFIER_RE2.test(table)) {
+      if (!IDENTIFIER_RE.test(table)) {
         throw new ReplicationError(`Invalid table name: ${table}`);
       }
     }
-    await conn.exec("PRAGMA foreign_keys = OFF");
+    await setForeignKeysEnabled(conn, false);
     try {
       await conn.transaction(async (tx) => {
         for (const table of tables) {
@@ -1071,10 +139,10 @@ CREATE TABLE IF NOT EXISTS ${SYNC_STATE_TABLE} (
         for (const table of reversed) {
           await tx.exec(`DELETE FROM "${table}"`);
         }
-        await tx.exec(`DELETE FROM ${SYNC_STATE_TABLE} WHERE table_name != '__sync_meta__'`);
+        await deleteSyncTableStates(tx);
       });
     } finally {
-      await conn.exec("PRAGMA foreign_keys = ON");
+      await setForeignKeysEnabled(conn, true);
     }
   }
 };
@@ -1085,98 +153,26 @@ var StateOps = class {
     this.conn = conn;
   }
   activeSyncSnapshotSeqs = /* @__PURE__ */ new Set();
-  /**
-   * Returns the highest valid HLC observed in this database, or `null` when
-   * no replication evidence exists yet.
-   *
-   * Reads two durable sources and takes the lexicographic maximum:
-   * - `MAX(hlc) FROM <changes table>` covers HLCs stamped onto local writes.
-   * - `MAX(hlc) FROM _sirannon_column_versions` covers HLCs applied from
-   *   remote batches and persisted alongside per-column versions.
-   *
-   * Combining both is necessary: a primary that has never received remote
-   * batches has no rows in `_sirannon_column_versions` for inbound HLCs, and
-   * a replica that has never written locally has no rows in the changes
-   * table. Either source can independently hold the highest value depending
-   * on traffic patterns.
-   *
-   * The changes table is subject to retention pruning by `ChangeTracker`,
-   * which means its `MAX(hlc)` can lag behind the highest HLC ever emitted.
-   * Cross-checking against `_sirannon_column_versions` (which is upserted
-   * per `(table, row, column)` and not subject to time-based retention)
-   * keeps the recovered value above any HLC currently still observable by
-   * any peer's conflict-resolution decisions.
-   *
-   * Filters out the empty-string sentinel that the CDC triggers write before
-   * the local-stamp pass fills in a real HLC, and rejects any decoded
-   * timestamp whose components are not finite, non-negative integers. The
-   * SQL filter narrows the result set; the JavaScript-level guard catches a
-   * future producer that writes a malformed HLC.
-   */
   async recoverMaxObservedHlc(changesTable) {
     let best = null;
-    const changesStmt = await this.conn.prepare(`SELECT MAX(hlc) AS max_hlc FROM "${changesTable}" WHERE hlc != ''`);
-    const changesRow = await changesStmt.get();
-    best = mergeCandidate(best, changesRow?.max_hlc ?? null);
-    const versionsStmt = await this.conn.prepare(
-      `SELECT MAX(hlc) AS max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE hlc != ''`
-    );
-    const versionsRow = await versionsStmt.get();
-    best = mergeCandidate(best, versionsRow?.max_hlc ?? null);
+    best = mergeCandidate(best, await selectMaxChangeHlc(this.conn, changesTable));
+    best = mergeCandidate(best, await selectMaxColumnVersionHlc(this.conn));
     return best;
   }
-  async getLastAppliedSeq(fromNodeId) {
-    const stmt = await this.conn.prepare(
-      `SELECT MAX(source_seq) as max_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ?`
-    );
-    const row = await stmt.get(fromNodeId);
-    if (!row || row.max_seq === null) {
-      return 0n;
-    }
-    return BigInt(row.max_seq);
-  }
-  async setLastAppliedSeq(fromNodeId, seq) {
-    const stmt = await this.conn.prepare(
-      `INSERT INTO ${PEER_STATE_TABLE} (peer_node_id, last_acked_seq, updated_at)
-       VALUES (?, ?, ?)
-       ON CONFLICT(peer_node_id)
-       DO UPDATE SET
-         last_acked_seq = max(${PEER_STATE_TABLE}.last_acked_seq, excluded.last_acked_seq),
-         updated_at = CASE
-           WHEN excluded.last_acked_seq >= ${PEER_STATE_TABLE}.last_acked_seq THEN excluded.updated_at
-           ELSE ${PEER_STATE_TABLE}.updated_at
-         END`
-    );
-    await stmt.run(fromNodeId, seq.toString(), Date.now() / 1e3);
+  getLastAppliedSeq(fromNodeId) {
+    return selectMaxAppliedSourceSeq(this.conn, fromNodeId);
   }
-  async getPeerAckedSeq(peerNodeId) {
-    const stmt = await this.conn.prepare(`SELECT last_acked_seq FROM ${PEER_STATE_TABLE} WHERE peer_node_id = ?`);
-    const row = await stmt.get(peerNodeId);
-    if (!row || row.last_acked_seq === null) {
-      return 0n;
-    }
-    return BigInt(row.last_acked_seq);
+  setLastAppliedSeq(fromNodeId, seq) {
+    return upsertPeerAckedSeq(this.conn, fromNodeId, seq, Date.now() / 1e3);
+  }
+  getPeerAckedSeq(peerNodeId) {
+    return selectPeerAckedSeq(this.conn, peerNodeId);
   }
   async getLocalSeq(changesTable) {
-    const stmt = await this.conn.prepare(`SELECT MAX(seq) as max_seq FROM "${changesTable}"`);
-    const row = await stmt.get();
-    if (!row || row.max_seq === null) {
-      return 0n;
-    }
-    return BigInt(row.max_seq);
+    return selectMaxChangeSeq(this.conn, changesTable);
   }
   async getMinAckedSeq() {
-    const stmt = await this.conn.prepare(
-      `SELECT MIN(last_acked_seq) as min_seq, COUNT(*) as cnt FROM ${PEER_STATE_TABLE}`
-    );
-    const row = await stmt.get();
-    const hasPeers = row !== void 0 && row.cnt > 0;
-    let result = null;
-    if (hasPeers && row.min_seq !== null) {
-      result = BigInt(row.min_seq);
-    } else if (hasPeers) {
-      result = 0n;
-    }
+    let result = await selectMinPeerAckedSeq(this.conn);
     for (const syncSeq of this.activeSyncSnapshotSeqs) {
       if (result === null || syncSeq < result) {
         result = syncSeq;
@@ -1190,75 +186,41 @@ var StateOps = class {
   unregisterActiveSyncSeq(seq) {
     this.activeSyncSnapshotSeqs.delete(seq);
   }
-  async setSyncTableStatus(table, status, rowCount, pkHash) {
-    const stmt = await this.conn.prepare(
-      `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, row_count, pk_hash, completed_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(table_name) DO UPDATE SET
-         status = excluded.status,
-         row_count = COALESCE(excluded.row_count, row_count),
-         pk_hash = COALESCE(excluded.pk_hash, pk_hash),
-         completed_at = excluded.completed_at`
-    );
-    await stmt.run(table, status, rowCount ?? 0, pkHash ?? "", status === "completed" ? Date.now() / 1e3 : null);
-  }
-  async setSyncMeta(phase, snapshotSeq, sourcePeerId, requestId) {
-    const stmt = await this.conn.prepare(
-      `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, snapshot_seq, source_peer_id, started_at, request_id)
-       VALUES ('__sync_meta__', ?, ?, ?, ?, ?)
-       ON CONFLICT(table_name) DO UPDATE SET
-         status = excluded.status,
-         snapshot_seq = COALESCE(excluded.snapshot_seq, snapshot_seq),
-         source_peer_id = COALESCE(excluded.source_peer_id, source_peer_id),
-         started_at = COALESCE(excluded.started_at, started_at),
-         request_id = COALESCE(excluded.request_id, request_id)`
-    );
-    await stmt.run(
-      phase,
-      snapshotSeq !== void 0 ? snapshotSeq.toString() : null,
-      sourcePeerId ?? null,
-      phase === "syncing" ? Date.now() / 1e3 : null,
-      requestId ?? null
-    );
+  setSyncTableStatus(table, status, rowCount, pkHash) {
+    return upsertSyncTableStatus(this.conn, {
+      tableName: table,
+      status,
+      rowCount: rowCount ?? 0,
+      pkHash: pkHash ?? "",
+      completedAt: status === "completed" ? Date.now() / 1e3 : null
+    });
+  }
+  setSyncMeta(phase, snapshotSeq, sourcePeerId, requestId) {
+    return upsertSyncMeta(this.conn, {
+      status: phase,
+      snapshotSeq,
+      sourcePeerId,
+      startedAt: phase === "syncing" ? Date.now() / 1e3 : null,
+      requestId
+    });
   }
   async getSyncState() {
-    const metaStmt = await this.conn.prepare(
-      `SELECT status, snapshot_seq, source_peer_id FROM ${SYNC_STATE_TABLE} WHERE table_name = '__sync_meta__'`
-    );
-    const meta = await metaStmt.get();
+    const meta = await selectSyncMetaRow(this.conn);
     if (!meta) {
       return { phase: "ready", completedTables: [], snapshotSeq: null, sourcePeerId: null };
     }
-    const completedStmt = await this.conn.prepare(
-      `SELECT table_name FROM ${SYNC_STATE_TABLE} WHERE table_name != '__sync_meta__' AND status = 'completed'`
-    );
-    const completedRows = await completedStmt.all();
     return {
       phase: meta.status,
-      completedTables: completedRows.map((r) => r.table_name),
-      snapshotSeq: meta.snapshot_seq !== null ? BigInt(meta.snapshot_seq) : null,
-      sourcePeerId: meta.source_peer_id
+      completedTables: await selectCompletedSyncTableNames(this.conn),
+      snapshotSeq: meta.snapshotSeq,
+      sourcePeerId: meta.sourcePeerId
     };
   }
   async isSyncCompleted() {
-    const stmt = await this.conn.prepare(`SELECT status FROM ${SYNC_STATE_TABLE} WHERE table_name = '__sync_meta__'`);
-    const row = await stmt.get();
-    return row?.status === "ready";
+    const meta = await selectSyncMetaRow(this.conn);
+    return meta?.status === "ready";
   }
 };
-function isWellFormedHlc(candidate) {
-  if (candidate.length === 0) return false;
-  let decoded;
-  try {
-    decoded = HLC.decode(candidate);
-  } catch {
-    return false;
-  }
-  if (!Number.isInteger(decoded.wallMs) || decoded.wallMs < 0) return false;
-  if (!Number.isInteger(decoded.logical) || decoded.logical < 0) return false;
-  if (decoded.nodeId.length === 0) return false;
-  return true;
-}
 function mergeCandidate(current, candidate) {
   if (candidate === null || candidate.length === 0) return current;
   if (!isWellFormedHlc(candidate)) return current;
@@ -1273,15 +235,17 @@ var ReplicationLog = class {
     this.pkResolver = new PkResolver(conn);
     this.state = new StateOps(conn);
     this.schema = new SchemaOps(conn, changesTable);
-    this.batchReader = new BatchReader(conn, localNodeId, hlc, changesTable, this.pkResolver);
+    this.batchReader = new BatchReader(conn, localNodeId, changesTable, this.pkResolver);
     this.batchApplier = new BatchApplier(
       conn,
       localNodeId,
       hlc,
       this.pkResolver,
       (fromNodeId) => this.state.getLastAppliedSeq(fromNodeId),
-      tracker
+      tracker,
+      changesTable
     );
+    this.stampOps = new StampOps(localNodeId, hlc, changesTable);
     this.dump = new DumpOps(conn, localNodeId, hlc, this.pkResolver);
   }
   pkResolver;
@@ -1289,6 +253,7 @@ var ReplicationLog = class {
   schema;
   batchReader;
   batchApplier;
+  stampOps;
   dump;
   ensureReplicationTables() {
     return this.schema.ensureReplicationTables();
@@ -1297,10 +262,10 @@ var ReplicationLog = class {
     return this.batchReader.readBatch(afterSeq, batchSize);
   }
   stampChanges(tx, afterSeq, txId) {
-    return this.batchReader.stampChanges(tx, afterSeq, txId);
+    return this.stampOps.stampChanges(tx, afterSeq, txId);
   }
   updateColumnVersions(tx, afterSeq) {
-    return this.batchReader.updateColumnVersions(tx, afterSeq);
+    return this.stampOps.updateColumnVersions(tx, afterSeq);
   }
   applyBatch(batch, resolver) {
     return this.batchApplier.applyBatch(batch, resolver);
@@ -1465,153 +430,984 @@ var PeerTracker = class {
       this.waiters.add(waiter);
     });
   }
-  waitForAll(seq, timeoutMs) {
-    const connected = this.connectedPeerCount();
-    if (connected === 0 || this.countAcked(seq) >= connected) {
-      return Promise.resolve();
+  waitForAll(seq, timeoutMs) {
+    const connected = this.connectedPeerCount();
+    if (connected === 0 || this.countAcked(seq) >= connected) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new WriteConcernError(`Timed out waiting for all peers to ACK seq ${seq}`));
+      }, timeoutMs);
+      timer.unref?.();
+      const waiter = { seq, kind: "all", resolve, reject, timer };
+      this.waiters.add(waiter);
+    });
+  }
+  waitForConfiguredMajority(seq, localNodeId, votingNodeIds, timeoutMs) {
+    const needed = Math.floor(votingNodeIds.length / 2) + 1;
+    if (this.countAckedConfigured(seq, localNodeId, votingNodeIds) >= needed) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new WriteConcernError(`Timed out waiting for configured majority ACK of seq ${seq}`));
+      }, timeoutMs);
+      timer.unref?.();
+      const waiter = {
+        seq,
+        kind: "configured-majority",
+        localNodeId,
+        votingNodeIds: [...votingNodeIds],
+        resolve,
+        reject,
+        timer
+      };
+      this.waiters.add(waiter);
+    });
+  }
+  waitForConfiguredAll(seq, localNodeId, votingNodeIds, timeoutMs) {
+    if (this.countAckedConfigured(seq, localNodeId, votingNodeIds) >= votingNodeIds.length) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new WriteConcernError(`Timed out waiting for all configured voters to ACK seq ${seq}`));
+      }, timeoutMs);
+      timer.unref?.();
+      const waiter = {
+        seq,
+        kind: "configured-all",
+        localNodeId,
+        votingNodeIds: [...votingNodeIds],
+        resolve,
+        reject,
+        timer
+      };
+      this.waiters.add(waiter);
+    });
+  }
+  ackedConfiguredNodeIds(seq, localNodeId, votingNodeIds) {
+    const acked = /* @__PURE__ */ new Set();
+    if (votingNodeIds.includes(localNodeId)) {
+      acked.add(localNodeId);
+    }
+    for (const nodeId of votingNodeIds) {
+      const peer = this.peers.get(nodeId);
+      if (peer && peer.lastAckedSeq >= seq) {
+        acked.add(nodeId);
+      }
+    }
+    return votingNodeIds.filter((nodeId) => acked.has(nodeId));
+  }
+  allPeerStates() {
+    return Array.from(this.peers.values());
+  }
+  countAcked(seq) {
+    let count = 0;
+    for (const peer of this.peers.values()) {
+      if (peer.connected && peer.lastAckedSeq >= seq) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  countAckedConfigured(seq, localNodeId, votingNodeIds) {
+    return this.ackedConfiguredNodeIds(seq, localNodeId, votingNodeIds).length;
+  }
+  checkWaiters() {
+    const connected = this.connectedPeerCount();
+    for (const waiter of this.waiters) {
+      let needed;
+      if (waiter.kind === "majority") {
+        needed = Math.floor(connected / 2) + 1;
+      } else if (waiter.kind === "configured-majority") {
+        const votingNodeIds = waiter.votingNodeIds ?? [];
+        const localNodeId = waiter.localNodeId ?? "";
+        needed = Math.floor(votingNodeIds.length / 2) + 1;
+        if (this.countAckedConfigured(waiter.seq, localNodeId, votingNodeIds) >= needed) {
+          clearTimeout(waiter.timer);
+          this.waiters.delete(waiter);
+          waiter.resolve();
+        }
+        continue;
+      } else if (waiter.kind === "configured-all") {
+        const votingNodeIds = waiter.votingNodeIds ?? [];
+        const localNodeId = waiter.localNodeId ?? "";
+        needed = votingNodeIds.length;
+        if (this.countAckedConfigured(waiter.seq, localNodeId, votingNodeIds) >= needed) {
+          clearTimeout(waiter.timer);
+          this.waiters.delete(waiter);
+          waiter.resolve();
+        }
+        continue;
+      } else {
+        needed = connected;
+      }
+      if (connected === 0 || this.countAcked(waiter.seq) >= needed) {
+        clearTimeout(waiter.timer);
+        this.waiters.delete(waiter);
+        waiter.resolve();
+        continue;
+      }
+      if (waiter.kind === "all" && connected < this.peers.size) {
+        clearTimeout(waiter.timer);
+        this.waiters.delete(waiter);
+        waiter.reject(
+          new WriteConcernError(
+            `Cannot satisfy 'all' write concern: only ${connected}/${this.peers.size} peers connected`
+          )
+        );
+        continue;
+      }
+      const totalNodes = this.peers.size + 1;
+      const majorityNeeded = Math.floor(totalNodes / 2) + 1;
+      if (waiter.kind === "majority" && connected + 1 < majorityNeeded) {
+        clearTimeout(waiter.timer);
+        this.waiters.delete(waiter);
+        waiter.reject(
+          new WriteConcernError(
+            `Cannot satisfy 'majority' write concern: only ${connected + 1}/${totalNodes} nodes reachable`
+          )
+        );
+      }
+    }
+  }
+};
+
+// src/replication/engine/constants.ts
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_BATCH_INTERVAL_MS = 100;
+var DEFAULT_MAX_CLOCK_DRIFT_MS = 6e4;
+var DEFAULT_MAX_PENDING_BATCHES = 10;
+var DEFAULT_MAX_BATCH_CHANGES = 1e3;
+var DEFAULT_ACK_TIMEOUT_MS = 5e3;
+var DEFAULT_SYNC_BATCH_SIZE = 1e4;
+var DEFAULT_MAX_CONCURRENT_SYNCS = 2;
+var DEFAULT_MAX_SYNC_DURATION_MS = 18e5;
+var DEFAULT_MAX_SYNC_LAG_BEFORE_READY = 100;
+var DEFAULT_SYNC_ACK_TIMEOUT_MS = 3e4;
+var DEFAULT_CATCH_UP_DEADLINE_MS = 6e5;
+var DEFAULT_COORDINATOR_SESSION_TTL_MS = 1e4;
+var DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
+var SAFE_SQL_PREFIX_RE = /^\s*(INSERT|UPDATE|DELETE|SELECT|CREATE\s+TABLE|ALTER\s+TABLE|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
+var IDENTIFIER_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var DDL_DENY_RE = /\b(load_extension|ATTACH|randomblob|zeroblob|writefile|readfile|fts3_tokenizer)\b/i;
+var SYNC_SAFE_DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
+function isSyncSafeDdl(sql) {
+  if (!SYNC_SAFE_DDL_PREFIX_RE.test(sql)) return false;
+  if (sql.includes(";")) return false;
+  if (/\bAS\s+SELECT\b/i.test(sql)) return false;
+  if (DDL_DENY_RE.test(sql)) return false;
+  const body = sql.replace(SYNC_SAFE_DDL_PREFIX_RE, "");
+  if (/\bSELECT\b/i.test(body)) return false;
+  return true;
+}
+
+// src/replication/engine/coordinator-authority.ts
+function arraysEqual(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function errorDetails(engine, state) {
+  return {
+    currentPrimary: state?.currentPrimary ?? null,
+    primaryTerm: state?.primaryTerm.toString(),
+    replicationGroupId: engine.config.coordinator?.groupId
+  };
+}
+function hasCurrentPrimaryAuthorityFor(engine, state) {
+  return state.currentPrimary?.nodeId === engine.nodeId;
+}
+function noteCoordinatorContact(engine) {
+  engine.coordinatorLastContactMs = Date.now();
+}
+function isCoordinatorConnected(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return false;
+  if (engine.coordinatorLastContactMs === 0) return false;
+  const sessionTtlMs = config.sessionTtlMs ?? DEFAULT_COORDINATOR_SESSION_TTL_MS;
+  return Date.now() - engine.coordinatorLastContactMs < sessionTtlMs;
+}
+function effectiveTopologyRole(engine) {
+  const state = engine.coordinatorState;
+  if (!engine.isCoordinatorMode() || !state) return engine.config.topology.role;
+  return state.currentPrimary?.nodeId === engine.nodeId ? "primary" : "replica";
+}
+async function refreshCoordinatorState(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return null;
+  try {
+    const state = await config.coordinator.getReplicationGroupState(config.clusterId, config.groupId);
+    noteCoordinatorContact(engine);
+    engine.coordinatorState = state;
+    engine.coordinatorAuthority = state ? hasCurrentPrimaryAuthorityFor(engine, state) : false;
+    return state;
+  } catch {
+    engine.coordinatorAuthority = false;
+    throw new CoordinatorError(
+      "Coordinator is unavailable while refreshing replication-group authority",
+      errorDetails(engine, engine.coordinatorState)
+    );
+  }
+}
+function getCoordinatorMessageFields(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return {};
+  return {
+    groupId: config.groupId,
+    primaryTerm: engine.coordinatorState?.primaryTerm ?? engine.config.transportConfig?.primaryTerm
+  };
+}
+function getForwardingPrimaryPeerId(engine) {
+  if (engine.isCoordinatorMode()) {
+    const primaryId = engine.coordinatorState?.currentPrimary?.nodeId;
+    if (primaryId && engine.config.transport.peers().has(primaryId)) {
+      return primaryId;
+    }
+    return null;
+  }
+  for (const [peerId, info] of engine.config.transport.peers()) {
+    if (info.role === "primary") {
+      return peerId;
+    }
+  }
+  return null;
+}
+function assertLocalCompatibility(engine, state) {
+  if (compatibilityAllowsPromotion(state.compatibility, engine.config.coordinator?.compatibility)) return;
+  throw new ProtocolVersionMismatchError("Node compatibility metadata is incompatible with the replication group", {
+    ...errorDetails(engine, state),
+    groupCompatibility: state.compatibility,
+    localCompatibility: engine.config.coordinator?.compatibility
+  });
+}
+async function canAcceptLocalWrite(engine) {
+  if (!engine.isCoordinatorMode()) {
+    return engine.config.topology.canWrite();
+  }
+  const state = await refreshCoordinatorState(engine);
+  if (!state) {
+    throw new CoordinatorError("Cannot prove write authority without replication-group state");
+  }
+  if (!hasCurrentPrimaryAuthorityFor(engine, state)) {
+    return false;
+  }
+  assertLocalCompatibility(engine, state);
+  if (state.drainingNodeIds.includes(engine.nodeId)) {
+    throw new NodeDrainingError("Node is draining and cannot accept writes", errorDetails(engine, state));
+  }
+  if (state.repairingNodeIds.includes(engine.nodeId) || state.faultedNodeIds.includes(engine.nodeId)) {
+    throw new AuthorityError(
+      "Node is not eligible to accept writes while repair or fault state is active",
+      "AUTHORITY_LOST",
+      errorDetails(engine, state)
+    );
+  }
+  return true;
+}
+function throwNotCurrentPrimary(engine) {
+  if (engine.isCoordinatorMode()) {
+    throw new StalePrimaryError("This node is not the current primary", errorDetails(engine, engine.coordinatorState));
+  }
+  throw new TopologyError("This node cannot accept writes");
+}
+async function assertReadConcern(engine, level) {
+  if (!engine.isCoordinatorMode()) return;
+  const readConcern = level ?? "majority";
+  if (readConcern === "local") return;
+  const state = await refreshCoordinatorState(engine);
+  if (!state) {
+    throw new CoordinatorError("Cannot satisfy read concern without replication-group state");
+  }
+  if (readConcern === "linearizable") {
+    await verifyPrimaryAuthority(engine);
+    return;
+  }
+  if (readConcern === "majority") {
+    if (!state.inSyncNodeIds.includes(engine.nodeId)) {
+      throw new NodeNotInSyncError("Node is not in the in-sync set for majority reads", errorDetails(engine, state));
+    }
+    if (state.drainingNodeIds.includes(engine.nodeId) || state.repairingNodeIds.includes(engine.nodeId)) {
+      throw new ReadConcernError(
+        "Node cannot serve majority reads while draining or repairing",
+        errorDetails(engine, state)
+      );
+    }
+    return;
+  }
+  throw new ReadConcernError(`Unsupported read concern '${readConcern}'`, errorDetails(engine, state));
+}
+async function verifyPrimaryAuthority(engine) {
+  const state = await refreshCoordinatorState(engine);
+  if (!state) {
+    throw new CoordinatorError("Cannot prove primary authority without replication-group state");
+  }
+  if (!hasCurrentPrimaryAuthorityFor(engine, state)) {
+    throw new StalePrimaryError(
+      "Node is not the current primary for this replication group",
+      errorDetails(engine, state)
+    );
+  }
+  assertLocalCompatibility(engine, state);
+  if (state.drainingNodeIds.includes(engine.nodeId)) {
+    throw new NodeDrainingError("Node is draining and cannot accept writes", errorDetails(engine, state));
+  }
+  if (state.repairingNodeIds.includes(engine.nodeId) || state.faultedNodeIds.includes(engine.nodeId)) {
+    throw new AuthorityError(
+      "Node is not eligible to accept writes while repair or fault state is active",
+      "AUTHORITY_LOST",
+      errorDetails(engine, state)
+    );
+  }
+  return state;
+}
+async function assertInboundCoordinatorMessage(engine, message, fromPeerId, direction) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const state = engine.coordinatorState ?? await refreshCoordinatorState(engine);
+  if (!state) {
+    throw new CoordinatorError("Cannot validate coordinator message without replication-group state");
+  }
+  if (message.groupId !== config.groupId || message.primaryTerm !== state.primaryTerm) {
+    throw new StalePrimaryError(
+      `Rejected ${direction} message for stale or wrong replication group term`,
+      errorDetails(engine, state)
+    );
+  }
+  if ((direction === "batch" || direction === "sync-data") && fromPeerId !== state.currentPrimary?.nodeId) {
+    throw new StalePrimaryError(
+      `Rejected ${direction} message from non-current primary '${fromPeerId}'`,
+      errorDetails(engine, state)
+    );
+  }
+  if ((direction === "ack" || direction === "forward" || direction === "sync-request") && !hasCurrentPrimaryAuthorityFor(engine, state)) {
+    throw new StalePrimaryError(
+      `Rejected ${direction} message because this node is not current primary`,
+      errorDetails(engine, state)
+    );
+  }
+}
+async function updateCoordinatorProgressAfterWrite(engine, seq, state) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const ackedNodeIds = engine.peerTracker.ackedConfiguredNodeIds(seq, engine.nodeId, state.votingDataBearingNodeIds);
+  const retainedInSync = state.inSyncNodeIds.filter((nodeId) => ackedNodeIds.includes(nodeId));
+  let nextState = state;
+  if (!arraysEqual(retainedInSync, state.inSyncNodeIds) || state.durabilityPointSeq < seq) {
+    const updated = await config.coordinator.updateInSyncSet({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      inSyncNodeIds: retainedInSync,
+      durabilityPointSeq: seq
+    });
+    if (!updated) {
+      throw new CoordinatorError("Failed to update in-sync set before acknowledging majority write");
+    }
+    nextState = updated;
+  }
+  for (const nodeId of ackedNodeIds) {
+    if (nextState.inSyncNodeIds.includes(nodeId)) continue;
+    if (nodeId === engine.nodeId) continue;
+    const admitted = await config.coordinator.admitNodeToInSyncSet({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      nodeId,
+      sourceNodeId: engine.nodeId,
+      appliedSeq: seq
+    });
+    if (!admitted) {
+      throw new CoordinatorError("Failed to admit ACKing node to in-sync set before acknowledging majority write");
+    }
+    nextState = admitted;
+  }
+  engine.coordinatorState = nextState;
+}
+async function waitForWriteConcern(engine, seq, wc) {
+  const timeout = wc.timeoutMs ?? 5e3;
+  if (engine.isCoordinatorMode()) {
+    const state = engine.coordinatorState ?? await refreshCoordinatorState(engine);
+    if (!state) {
+      throw new CoordinatorError("Cannot satisfy write concern without replication-group state");
+    }
+    if (wc.level === "majority") {
+      await engine.peerTracker.waitForConfiguredMajority(seq, engine.nodeId, state.votingDataBearingNodeIds, timeout);
+      await updateCoordinatorProgressAfterWrite(engine, seq, state);
+    } else if (wc.level === "all") {
+      const eligibleVoters = state.votingDataBearingNodeIds.filter((nodeId) => !state.drainingNodeIds.includes(nodeId));
+      await engine.peerTracker.waitForConfiguredAll(seq, engine.nodeId, eligibleVoters, timeout);
+      await updateCoordinatorProgressAfterWrite(engine, seq, state);
+    }
+    return;
+  }
+  if (wc.level === "majority") {
+    await engine.peerTracker.waitForMajority(seq, timeout);
+  } else if (wc.level === "all") {
+    await engine.peerTracker.waitForAll(seq, timeout);
+  }
+}
+function getCoordinatorRuntimeStatus(engine) {
+  const config = engine.config.coordinator;
+  const state = engine.coordinatorState;
+  if (!config || !state) return void 0;
+  return {
+    clusterId: config.clusterId,
+    groupId: config.groupId,
+    currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
+    primaryTerm: state.primaryTerm,
+    inSyncNodeIds: [...state.inSyncNodeIds],
+    drainingNodeIds: [...state.drainingNodeIds],
+    repairingNodeIds: [...state.repairingNodeIds],
+    faultedNodeIds: [...state.faultedNodeIds],
+    votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
+    authority: engine.coordinatorAuthority,
+    connected: isCoordinatorConnected(engine),
+    controllerState: engine.controllerState
+  };
+}
+
+// src/replication/engine/coordinator-membership.ts
+function requiresCoordinatorRejoin(engine, state) {
+  if (state.currentPrimary?.nodeId === engine.nodeId) return false;
+  return state.repairingNodeIds.includes(engine.nodeId) || state.faultedNodeIds.includes(engine.nodeId);
+}
+function requiresCoordinatorRejoinSync(engine, state) {
+  if (!state || state.currentPrimary?.nodeId === engine.nodeId) return false;
+  if (state.faultedNodeIds.includes(engine.nodeId)) return false;
+  return state.repairingNodeIds.includes(engine.nodeId);
+}
+async function prepareCoordinatorRejoinIfNeeded(engine) {
+  const state = engine.coordinatorState ?? await refreshCoordinatorState(engine);
+  if (!state || !requiresCoordinatorRejoin(engine, state)) return;
+  await evaluateFormerPrimaryHistory(engine, state);
+}
+async function markCoordinatorSyncReady(engine) {
+  const config = engine.config.coordinator;
+  const state = engine.coordinatorState ?? await refreshCoordinatorState(engine);
+  if (!config || !state || state.currentPrimary?.nodeId === engine.nodeId) return;
+  if (!state.votingDataBearingNodeIds.includes(engine.nodeId)) return;
+  if (state.faultedNodeIds.includes(engine.nodeId)) return;
+  if (state.drainingNodeIds.includes(engine.nodeId)) {
+    await removeLocalNodeFromCoordinatorInSyncSet(engine, state);
+    return;
+  }
+  const needsAdmission = !state.inSyncNodeIds.includes(engine.nodeId) || state.repairingNodeIds.includes(engine.nodeId);
+  if (!needsAdmission) {
+    engine.coordinatorState = state;
+    engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, state);
+    return;
+  }
+  const sourceNodeId = state.currentPrimary?.nodeId;
+  if (!sourceNodeId || engine.syncState.sourcePeerId !== sourceNodeId) {
+    engine.coordinatorState = state;
+    engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, state);
+    return;
+  }
+  const appliedSeq = await engine.log.getLastAppliedSeq(sourceNodeId);
+  if (appliedSeq < state.durabilityPointSeq) {
+    engine.coordinatorState = state;
+    engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, state);
+    return;
+  }
+  const admitted = await config.coordinator.admitNodeToInSyncSet({
+    clusterId: config.clusterId,
+    groupId: config.groupId,
+    nodeId: engine.nodeId,
+    sourceNodeId,
+    appliedSeq
+  });
+  engine.coordinatorState = admitted ?? state;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, engine.coordinatorState);
+}
+async function handleCoordinatorAckProgress(engine, nodeId, ackedSeq) {
+  const config = engine.config.coordinator;
+  const state = engine.coordinatorState;
+  if (!config || !state) return;
+  if (nodeId === engine.nodeId) return;
+  if (!hasCurrentPrimaryAuthorityFor(engine, state)) return;
+  if (state.inSyncNodeIds.includes(nodeId)) return;
+  if (!state.votingDataBearingNodeIds.includes(nodeId)) return;
+  if (ackedSeq < state.durabilityPointSeq) return;
+  const admitted = await config.coordinator.admitNodeToInSyncSet({
+    clusterId: config.clusterId,
+    groupId: config.groupId,
+    nodeId,
+    sourceNodeId: engine.nodeId,
+    appliedSeq: ackedSeq
+  });
+  if (!admitted) return;
+  engine.coordinatorState = admitted;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, admitted);
+}
+async function reconcileInSyncSet(engine) {
+  if (!engine.running || engine.inSyncReconciling) return;
+  const state = engine.coordinatorState;
+  if (!state || !hasCurrentPrimaryAuthorityFor(engine, state)) return;
+  const caughtUpNodeIds = engine.peerTracker.ackedConfiguredNodeIds(
+    state.durabilityPointSeq,
+    engine.nodeId,
+    state.votingDataBearingNodeIds
+  );
+  const pending = caughtUpNodeIds.filter((nodeId) => nodeId !== engine.nodeId && !state.inSyncNodeIds.includes(nodeId));
+  if (pending.length === 0) return;
+  engine.inSyncReconciling = true;
+  try {
+    for (const nodeId of pending) {
+      await handleCoordinatorAckProgress(engine, nodeId, state.durabilityPointSeq);
+    }
+  } finally {
+    engine.inSyncReconciling = false;
+  }
+}
+async function removeLocalNodeFromCoordinatorInSyncSet(engine, state) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const inSyncNodeIds = state.inSyncNodeIds.filter((nodeId) => nodeId !== engine.nodeId);
+  let nextState = state;
+  if (!arraysEqual(inSyncNodeIds, state.inSyncNodeIds)) {
+    const updated = await config.coordinator.updateInSyncSet({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      inSyncNodeIds
+    });
+    if (!updated) {
+      throw new CoordinatorError("Failed to mark repaired node as in sync");
+    }
+    nextState = updated;
+  }
+  engine.coordinatorState = nextState;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, nextState);
+}
+function startCoordinatorRejoinSyncIfReady(engine, state) {
+  if (!engine.running) return;
+  if (engine.coordinatorRejoinSyncStarting) return;
+  if (!requiresCoordinatorRejoinSync(engine, state)) return;
+  if (engine.syncState.phase !== "pending") return;
+  const sourceNodeId = state.currentPrimary?.nodeId;
+  if (!sourceNodeId || !engine.config.transport.peers().has(sourceNodeId)) return;
+  engine.coordinatorRejoinSyncStarting = true;
+  engine.syncJoiner.initiateSync().catch((err) => {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "coordinator-rejoin-sync", recoverable: true });
+  }).finally(() => {
+    engine.coordinatorRejoinSyncStarting = false;
+  });
+}
+async function handleFormerPrimaryDemotion(engine, state) {
+  const repairingState = await markLocalNodeRepairing(engine, state);
+  const evaluatedState = await evaluateFormerPrimaryHistory(engine, repairingState);
+  if (!requiresCoordinatorRejoinSync(engine, evaluatedState)) return;
+  if (!engine.running || engine.syncState.phase === "syncing" || engine.syncState.phase === "catching-up") return;
+  engine.syncState = {
+    phase: "pending",
+    sourcePeerId: null,
+    snapshotSeq: null,
+    completedTables: [],
+    totalTables: 0,
+    startedAt: null,
+    error: null
+  };
+  await engine.log.setSyncMeta("pending");
+  await engine.syncJoiner.initiateSync();
+}
+async function markLocalNodeRepairing(engine, state) {
+  const config = engine.config.coordinator;
+  if (!config || state.repairingNodeIds.includes(engine.nodeId) || state.faultedNodeIds.includes(engine.nodeId)) {
+    return state;
+  }
+  const updated = await config.coordinator.updateNodeMaintenance({
+    clusterId: config.clusterId,
+    groupId: config.groupId,
+    nodeId: engine.nodeId,
+    repairing: true
+  });
+  if (!updated) {
+    throw new CoordinatorError("Failed to mark former primary for repair");
+  }
+  engine.coordinatorState = updated;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, updated);
+  return updated;
+}
+async function evaluateFormerPrimaryHistory(engine, state) {
+  const config = engine.config.coordinator;
+  const currentPrimary = state.currentPrimary;
+  if (!config || !currentPrimary || state.faultedNodeIds.includes(engine.nodeId)) return state;
+  const localSeq = await engine.log.getLocalSeq();
+  const currentPrimaryAckedSeq = await engine.log.getPeerAckedSeq(currentPrimary.nodeId);
+  if (localSeq <= currentPrimaryAckedSeq) {
+    return state;
+  }
+  const inSyncNodeIds = state.inSyncNodeIds.filter((nodeId) => nodeId !== engine.nodeId);
+  let nextState = state;
+  if (inSyncNodeIds.length !== state.inSyncNodeIds.length) {
+    const updated = await config.coordinator.updateInSyncSet({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      inSyncNodeIds
+    });
+    if (!updated) {
+      throw new CoordinatorError("Failed to remove divergent former primary from in-sync set");
+    }
+    nextState = updated;
+  }
+  const faulted = await config.coordinator.updateNodeMaintenance({
+    clusterId: config.clusterId,
+    groupId: config.groupId,
+    nodeId: engine.nodeId,
+    repairing: false,
+    faulted: true
+  });
+  nextState = faulted ?? nextState;
+  engine.coordinatorState = nextState;
+  engine.coordinatorAuthority = false;
+  engine.emitError({
+    error: new AuthorityError("Former primary returned with local-only writes and was quarantined", "AUTHORITY_LOST", {
+      ...errorDetails(engine, nextState),
+      localSeq: localSeq.toString(),
+      currentPrimaryAckedSeq: currentPrimaryAckedSeq.toString()
+    }),
+    operation: "coordinator-former-primary-divergence",
+    recoverable: false
+  });
+  return nextState;
+}
+
+// src/replication/engine/coordinator-lifecycle.ts
+var DEFAULT_CONTROLLER_LEASE_TTL_MS = 1e4;
+var DEFAULT_CONTROLLER_TICK_INTERVAL_MS = 1e3;
+var IN_SYNC_RECONCILE_INTERVAL_MS = 1e3;
+function unrefTimer(timer) {
+  const unref = timer.unref;
+  unref?.call(timer);
+}
+function localCoordinatorPrimary(engine) {
+  const endpoint = engine.config.coordinator?.endpoint;
+  return endpoint ? { nodeId: engine.nodeId, endpoint } : { nodeId: engine.nodeId };
+}
+async function startCoordinatorMode(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const coordinator = config.coordinator;
+  let state = await coordinator.getReplicationGroupState(config.clusterId, config.groupId);
+  if (!state && config.votingDataBearingNodeIds) {
+    state = await coordinator.setReplicationGroupState({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      votingDataBearingNodeIds: config.votingDataBearingNodeIds,
+      currentPrimary: engine.config.topology.role === "primary" ? localCoordinatorPrimary(engine) : null,
+      primaryTerm: 1n,
+      inSyncNodeIds: [engine.nodeId],
+      compatibility: config.compatibility
+    });
+  }
+  if (!state) {
+    throw new CoordinatorError(`Replication group '${config.groupId}' is not registered`);
+  }
+  noteCoordinatorContact(engine);
+  engine.coordinatorState = state;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, state);
+  const session = await coordinator.registerNodeSession({
+    clusterId: config.clusterId,
+    nodeId: engine.nodeId,
+    ttlMs: config.sessionTtlMs ?? DEFAULT_COORDINATOR_SESSION_TTL_MS,
+    endpoint: config.endpoint,
+    groupIds: [config.groupId],
+    dataBearing: true,
+    voting: state.votingDataBearingNodeIds.includes(engine.nodeId),
+    compatibility: config.compatibility
+  });
+  engine.nodeSessionLeaseId = session.lease.id;
+  noteCoordinatorContact(engine);
+  engine.coordinatorWatchDisposer = await coordinator.watchReplicationGroup(config.clusterId, config.groupId, (next) => {
+    handleCoordinatorStateUpdate(engine, next);
+  });
+  startCoordinatorLeaseRenewal(engine);
+  startInSyncReconcileLoop(engine);
+  startControllerLoop(engine);
+}
+function startInSyncReconcileLoop(engine) {
+  const timer = setInterval(() => {
+    reconcileInSyncSet(engine).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "coordinator-in-sync-reconcile", recoverable: true });
+    });
+  }, IN_SYNC_RECONCILE_INTERVAL_MS);
+  unrefTimer(timer);
+  engine.inSyncReconcileTimer = timer;
+}
+function handleCoordinatorStateUpdate(engine, next) {
+  const previous = engine.coordinatorState;
+  const wasPrimary = previous ? hasCurrentPrimaryAuthorityFor(engine, previous) : engine.coordinatorAuthority;
+  noteCoordinatorContact(engine);
+  engine.coordinatorState = next;
+  engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, next);
+  if (wasPrimary && !engine.coordinatorAuthority && next.primaryTerm > (previous?.primaryTerm ?? 0n)) {
+    handleFormerPrimaryDemotion(engine, next).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "coordinator-former-primary-demotion", recoverable: false });
+    });
+    return;
+  }
+  startCoordinatorRejoinSyncIfReady(engine, next);
+}
+function startCoordinatorLeaseRenewal(engine) {
+  const config = engine.config.coordinator;
+  if (!config || !engine.nodeSessionLeaseId) return;
+  const ttlMs = config.sessionTtlMs ?? DEFAULT_COORDINATOR_SESSION_TTL_MS;
+  const timer = setInterval(
+    () => {
+      void keepCoordinatorSessionAlive(engine, ttlMs);
+    },
+    Math.max(1e3, Math.floor(ttlMs / 3))
+  );
+  unrefTimer(timer);
+  engine.coordinatorLeaseTimer = timer;
+}
+function applyAuthorityFromKnownState(engine) {
+  const state = engine.coordinatorState;
+  engine.coordinatorAuthority = state ? hasCurrentPrimaryAuthorityFor(engine, state) : false;
+}
+async function keepCoordinatorSessionAlive(engine, ttlMs) {
+  const config = engine.config.coordinator;
+  if (!config || !engine.running || engine.coordinatorSessionRestoring) return;
+  const leaseId = engine.nodeSessionLeaseId;
+  if (leaseId) {
+    try {
+      if (await config.coordinator.renewLease(leaseId, ttlMs)) {
+        noteCoordinatorContact(engine);
+        applyAuthorityFromKnownState(engine);
+        return;
+      }
+    } catch (err) {
+      engine.coordinatorAuthority = false;
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "coordinator-session-renew", recoverable: true });
+      return;
     }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.waiters.delete(waiter);
-        reject(new WriteConcernError(`Timed out waiting for all peers to ACK seq ${seq}`));
-      }, timeoutMs);
-      timer.unref?.();
-      const waiter = { seq, kind: "all", resolve, reject, timer };
-      this.waiters.add(waiter);
-    });
   }
-  waitForConfiguredMajority(seq, localNodeId, votingNodeIds, timeoutMs) {
-    const needed = Math.floor(votingNodeIds.length / 2) + 1;
-    if (this.countAckedConfigured(seq, localNodeId, votingNodeIds) >= needed) {
-      return Promise.resolve();
+  engine.coordinatorAuthority = false;
+  engine.nodeSessionLeaseId = null;
+  await restoreCoordinatorSession(engine, ttlMs);
+}
+async function restoreCoordinatorSession(engine, ttlMs) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  engine.coordinatorSessionRestoring = true;
+  try {
+    const state = await config.coordinator.getReplicationGroupState(config.clusterId, config.groupId);
+    if (!state) {
+      throw new CoordinatorError(`Replication group '${config.groupId}' is not registered`);
     }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.waiters.delete(waiter);
-        reject(new WriteConcernError(`Timed out waiting for configured majority ACK of seq ${seq}`));
-      }, timeoutMs);
-      timer.unref?.();
-      const waiter = {
-        seq,
-        kind: "configured-majority",
-        localNodeId,
-        votingNodeIds: [...votingNodeIds],
-        resolve,
-        reject,
-        timer
-      };
-      this.waiters.add(waiter);
+    const session = await config.coordinator.registerNodeSession({
+      clusterId: config.clusterId,
+      nodeId: engine.nodeId,
+      ttlMs,
+      endpoint: config.endpoint,
+      groupIds: [config.groupId],
+      dataBearing: true,
+      voting: state.votingDataBearingNodeIds.includes(engine.nodeId),
+      compatibility: config.compatibility
     });
+    if (!engine.running) {
+      await config.coordinator.releaseLease(session.lease.id).catch(() => void 0);
+      return;
+    }
+    engine.nodeSessionLeaseId = session.lease.id;
+    engine.coordinatorState = state;
+    noteCoordinatorContact(engine);
+    applyAuthorityFromKnownState(engine);
+  } catch (err) {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "coordinator-session-restore", recoverable: true });
+  } finally {
+    engine.coordinatorSessionRestoring = false;
   }
-  waitForConfiguredAll(seq, localNodeId, votingNodeIds, timeoutMs) {
-    if (this.countAckedConfigured(seq, localNodeId, votingNodeIds) >= votingNodeIds.length) {
-      return Promise.resolve();
+}
+function startControllerLoop(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const controllerConfig = typeof config.controller === "object" ? config.controller : {};
+  const enabled = typeof config.controller === "boolean" ? config.controller : controllerConfig.enabled ?? true;
+  if (!enabled) {
+    engine.controllerState = "disabled";
+    return;
+  }
+  engine.controllerState = "standby";
+  const ttlMs = controllerConfig.leaseTtlMs ?? DEFAULT_CONTROLLER_LEASE_TTL_MS;
+  const holderId = controllerConfig.holderId ?? engine.nodeId;
+  const tickMs = controllerConfig.tickIntervalMs ?? DEFAULT_CONTROLLER_TICK_INTERVAL_MS;
+  const timer = setInterval(() => {
+    controllerTick(engine, holderId, ttlMs).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.controllerState = "lost";
+      engine.emitError({ error: wrappedErr, operation: "coordinator-controller", recoverable: true });
+    });
+  }, tickMs);
+  unrefTimer(timer);
+  engine.controllerTimer = timer;
+}
+async function controllerTick(engine, holderId, ttlMs) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  if (engine.controllerLeaseId) {
+    const renewed = await config.coordinator.renewLease(engine.controllerLeaseId, ttlMs);
+    if (!renewed) {
+      engine.controllerLeaseId = null;
+      engine.controllerState = "lost";
+      return;
     }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.waiters.delete(waiter);
-        reject(new WriteConcernError(`Timed out waiting for all configured voters to ACK seq ${seq}`));
-      }, timeoutMs);
-      timer.unref?.();
-      const waiter = {
-        seq,
-        kind: "configured-all",
-        localNodeId,
-        votingNodeIds: [...votingNodeIds],
-        resolve,
-        reject,
-        timer
-      };
-      this.waiters.add(waiter);
+    noteCoordinatorContact(engine);
+    engine.controllerState = "active";
+    await runControllerPromotionCheck(engine);
+    return;
+  }
+  const acquired = await config.coordinator.tryAcquireControllerLease({
+    clusterId: config.clusterId,
+    holderId,
+    ttlMs
+  });
+  noteCoordinatorContact(engine);
+  if (acquired.acquired) {
+    engine.controllerLeaseId = acquired.lease.id;
+    engine.controllerState = "active";
+    await runControllerPromotionCheck(engine);
+  } else {
+    engine.controllerState = "standby";
+  }
+}
+async function runControllerPromotionCheck(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  const state = await refreshCoordinatorState(engine);
+  if (!state) return;
+  const primaryNodeId = state.currentPrimary?.nodeId;
+  const primaryLive = primaryNodeId ? await config.coordinator.getLiveNodeSession(config.clusterId, primaryNodeId) : null;
+  const primaryCanKeepDuty = primaryNodeId && primaryLive && compatibilityAllowsPromotion(state.compatibility, primaryLive.compatibility) && !state.drainingNodeIds.includes(primaryNodeId) && !state.repairingNodeIds.includes(primaryNodeId) && !state.faultedNodeIds.includes(primaryNodeId);
+  if (primaryCanKeepDuty) {
+    return;
+  }
+  try {
+    const promoted = await config.coordinator.promoteEligibleReplica({
+      clusterId: config.clusterId,
+      groupId: config.groupId,
+      excludeNodeIds: primaryNodeId ? [primaryNodeId] : []
     });
+    engine.coordinatorState = promoted;
+    engine.coordinatorAuthority = hasCurrentPrimaryAuthorityFor(engine, promoted);
+  } catch (err) {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "coordinator-promotion", recoverable: true });
   }
-  ackedConfiguredNodeIds(seq, localNodeId, votingNodeIds) {
-    const acked = /* @__PURE__ */ new Set();
-    if (votingNodeIds.includes(localNodeId)) {
-      acked.add(localNodeId);
-    }
-    for (const nodeId of votingNodeIds) {
-      const peer = this.peers.get(nodeId);
-      if (peer && peer.lastAckedSeq >= seq) {
-        acked.add(nodeId);
-      }
-    }
-    return votingNodeIds.filter((nodeId) => acked.has(nodeId));
+}
+function stopCoordinatorTimers(engine) {
+  if (engine.coordinatorLeaseTimer) {
+    clearInterval(engine.coordinatorLeaseTimer);
+    engine.coordinatorLeaseTimer = null;
   }
-  allPeerStates() {
-    return Array.from(this.peers.values());
+  if (engine.inSyncReconcileTimer) {
+    clearInterval(engine.inSyncReconcileTimer);
+    engine.inSyncReconcileTimer = null;
   }
-  countAcked(seq) {
-    let count = 0;
-    for (const peer of this.peers.values()) {
-      if (peer.connected && peer.lastAckedSeq >= seq) {
-        count += 1;
-      }
-    }
-    return count;
+  if (engine.controllerTimer) {
+    clearInterval(engine.controllerTimer);
+    engine.controllerTimer = null;
   }
-  countAckedConfigured(seq, localNodeId, votingNodeIds) {
-    return this.ackedConfiguredNodeIds(seq, localNodeId, votingNodeIds).length;
+}
+async function stopCoordinatorMode(engine) {
+  const config = engine.config.coordinator;
+  if (!config) return;
+  if (engine.coordinatorWatchDisposer) {
+    await engine.coordinatorWatchDisposer();
+    engine.coordinatorWatchDisposer = null;
+  }
+  if (engine.controllerLeaseId) {
+    const leaseId = engine.controllerLeaseId;
+    engine.controllerLeaseId = null;
+    await config.coordinator.releaseLease(leaseId).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "coordinator-controller-release", recoverable: true });
+    });
   }
-  checkWaiters() {
-    const connected = this.connectedPeerCount();
-    for (const waiter of this.waiters) {
-      let needed;
-      if (waiter.kind === "majority") {
-        needed = Math.floor(connected / 2) + 1;
-      } else if (waiter.kind === "configured-majority") {
-        const votingNodeIds = waiter.votingNodeIds ?? [];
-        const localNodeId = waiter.localNodeId ?? "";
-        needed = Math.floor(votingNodeIds.length / 2) + 1;
-        if (this.countAckedConfigured(waiter.seq, localNodeId, votingNodeIds) >= needed) {
-          clearTimeout(waiter.timer);
-          this.waiters.delete(waiter);
-          waiter.resolve();
-        }
-        continue;
-      } else if (waiter.kind === "configured-all") {
-        const votingNodeIds = waiter.votingNodeIds ?? [];
-        const localNodeId = waiter.localNodeId ?? "";
-        needed = votingNodeIds.length;
-        if (this.countAckedConfigured(waiter.seq, localNodeId, votingNodeIds) >= needed) {
-          clearTimeout(waiter.timer);
-          this.waiters.delete(waiter);
-          waiter.resolve();
-        }
-        continue;
-      } else {
-        needed = connected;
-      }
-      if (connected === 0 || this.countAcked(waiter.seq) >= needed) {
-        clearTimeout(waiter.timer);
-        this.waiters.delete(waiter);
-        waiter.resolve();
-        continue;
-      }
-      if (waiter.kind === "all" && connected < this.peers.size) {
-        clearTimeout(waiter.timer);
-        this.waiters.delete(waiter);
-        waiter.reject(
-          new WriteConcernError(
-            `Cannot satisfy 'all' write concern: only ${connected}/${this.peers.size} peers connected`
-          )
-        );
-        continue;
-      }
-      const totalNodes = this.peers.size + 1;
-      const majorityNeeded = Math.floor(totalNodes / 2) + 1;
-      if (waiter.kind === "majority" && connected + 1 < majorityNeeded) {
-        clearTimeout(waiter.timer);
-        this.waiters.delete(waiter);
-        waiter.reject(
-          new WriteConcernError(
-            `Cannot satisfy 'majority' write concern: only ${connected + 1}/${totalNodes} nodes reachable`
-          )
-        );
-      }
+  await config.coordinator.deregisterNodeSession(config.clusterId, engine.nodeId).catch((err) => {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "coordinator-session-deregister", recoverable: true });
+  });
+}
+function assertReadyPhase(engine, activity) {
+  if (engine.syncState.phase !== "ready") {
+    throw new SyncError(`Node is in '${engine.syncState.phase}' phase and cannot ${activity}`);
+  }
+}
+async function query(engine, sql, params, options) {
+  assertReadyPhase(engine, "serve reads");
+  await assertReadConcern(engine, options?.readConcern?.level);
+  return engine.database.query(sql, params, options);
+}
+async function execute(engine, sql, params, options) {
+  assertReadyPhase(engine, "accept operations");
+  if (!await canAcceptLocalWrite(engine)) {
+    if (engine.config.writeForwarding) {
+      const result = await forwardStatements(engine, [{ sql, params }]);
+      const first = result.results[0];
+      if (!first) {
+        return { changes: 0, lastInsertRowId: 0 };
+      }
+      return {
+        changes: first.changes,
+        lastInsertRowId: typeof first.lastInsertRowId === "string" ? BigInt(first.lastInsertRowId) : first.lastInsertRowId
+      };
     }
+    throwNotCurrentPrimary(engine);
   }
-};
+  return engine.localExecutor.executeLocally(sql, params, options);
+}
+async function executeBatch(engine, sql, paramsBatch, options) {
+  assertReadyPhase(engine, "accept operations");
+  if (!await canAcceptLocalWrite(engine)) {
+    if (engine.config.writeForwarding) {
+      const statements = paramsBatch.map((p) => ({ sql, params: p }));
+      const result = await forwardStatements(engine, statements);
+      return result.results.map((r) => ({
+        changes: r.changes,
+        lastInsertRowId: typeof r.lastInsertRowId === "string" ? BigInt(r.lastInsertRowId) : Number(r.lastInsertRowId)
+      }));
+    }
+    throwNotCurrentPrimary(engine);
+  }
+  const results = [];
+  for (const params of paramsBatch) {
+    const r = await engine.localExecutor.executeLocally(sql, params, options);
+    results.push(r);
+  }
+  return results;
+}
+async function transaction(engine, fn, options) {
+  assertReadyPhase(engine, "accept operations");
+  if (!await canAcceptLocalWrite(engine)) {
+    throw new TopologyError("This node cannot accept writes in transaction mode");
+  }
+  return engine.localExecutor.executeTransactionLocally(fn, options);
+}
+async function forwardStatements(engine, statements, _options) {
+  if (await canAcceptLocalWrite(engine)) {
+    return engine.localExecutor.executeForwardedLocally(statements);
+  }
+  const primaryPeerId = getForwardingPrimaryPeerId(engine);
+  if (primaryPeerId === null) {
+    throw new TopologyError("No primary node available for write forwarding");
+  }
+  return engine.config.transport.forward(primaryPeerId, {
+    statements,
+    requestId: randomUUID(),
+    ...getCoordinatorMessageFields(engine)
+  });
+}
 
 // src/replication/engine/replication-transaction.ts
 var ReplicationTransaction = class extends Transaction {
@@ -1672,12 +1468,12 @@ var LocalExecutor = class {
       const stmt = await tx.prepare(sql);
       const r = await stmt.run(...bindValues);
       if (isDdl) {
-        const ddlStmt = await tx.prepare(
-          `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
-           VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
-        );
-        const hlcVal = engine.hlc.now();
-        await ddlStmt.run(JSON.stringify({ ddlStatement: sql }), engine.nodeId, txId, hlcVal);
+        await insertDdlChange(tx, CHANGES_TABLE, {
+          ddlStatement: sql,
+          nodeId: engine.nodeId,
+          txId,
+          hlc: engine.hlc.now()
+        });
       } else {
         await engine.log.stampChanges(tx, seqBefore, txId);
         await engine.log.updateColumnVersions(tx, seqBefore);
@@ -1738,12 +1534,12 @@ var LocalExecutor = class {
           if (droppedTable !== null) {
             droppedTables.push(droppedTable);
           }
-          const ddlStmt = await tx.prepare(
-            `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
-             VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
-          );
-          const hlcVal = engine.hlc.now();
-          await ddlStmt.run(JSON.stringify({ ddlStatement: sql }), engine.nodeId, txId, hlcVal);
+          await insertDdlChange(tx, CHANGES_TABLE, {
+            ddlStatement: sql,
+            nodeId: engine.nodeId,
+            txId,
+            hlc: engine.hlc.now()
+          });
           if (engine.tracker) {
             await engine.tracker.refreshAllTriggersUsingConnection(tx);
           }
@@ -1789,12 +1585,12 @@ var LocalExecutor = class {
         if (droppedTable !== null) {
           hooks.droppedTables.push(droppedTable);
         }
-        const ddlStmt = await tx.prepare(
-          `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
-           VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
-        );
-        const hlcVal = engine.hlc.now();
-        await ddlStmt.run(JSON.stringify({ ddlStatement: sql }), engine.nodeId, txId, hlcVal);
+        await insertDdlChange(tx, CHANGES_TABLE, {
+          ddlStatement: sql,
+          nodeId: engine.nodeId,
+          txId,
+          hlc: engine.hlc.now()
+        });
         if (engine.tracker) {
           await engine.tracker.refreshAllTriggersUsingConnection(tx);
         }
@@ -1823,6 +1619,54 @@ var LocalExecutor = class {
   }
 };
 
+// src/replication/engine/node-health.ts
+function isSidelined(state, nodeId) {
+  return state.drainingNodeIds.includes(nodeId) || state.repairingNodeIds.includes(nodeId) || state.faultedNodeIds.includes(nodeId);
+}
+function excludingReason(state, nodeId) {
+  if (state.drainingNodeIds.includes(nodeId)) return "draining";
+  if (state.faultedNodeIds.includes(nodeId)) return "faulted";
+  return "sync-pending";
+}
+function staticHealth(engine, phase) {
+  if (phase !== "ready") {
+    return { state: "unavailable", reason: "sync-pending", canRead: false, canWrite: false };
+  }
+  return { state: "healthy", reason: "in-sync", canRead: true, canWrite: engine.config.topology.canWrite() };
+}
+function computeNodeHealth(engine) {
+  const phase = engine.syncState.phase;
+  if (phase === "syncing" || phase === "catching-up") {
+    return { state: "syncing", reason: "sync-pending", canRead: false, canWrite: false };
+  }
+  if (!engine.isCoordinatorMode()) {
+    return staticHealth(engine, phase);
+  }
+  const state = engine.coordinatorState;
+  if (!state) {
+    return { state: "unavailable", reason: "no-group-state", canRead: false, canWrite: false };
+  }
+  const nodeId = engine.nodeId;
+  const canRead = phase === "ready" && !isSidelined(state, nodeId);
+  const canWrite = canRead && engine.coordinatorAuthority;
+  if (state.repairingNodeIds.includes(nodeId)) {
+    return { state: "repairing", reason: "repairing", canRead, canWrite };
+  }
+  if (engine.coordinatorAuthority && !canWrite) {
+    return { state: "failing_over", reason: excludingReason(state, nodeId), canRead, canWrite };
+  }
+  if (!canRead) {
+    return { state: "unavailable", reason: excludingReason(state, nodeId), canRead, canWrite };
+  }
+  if (!isCoordinatorConnected(engine)) {
+    return { state: "degraded", reason: "coordinator-unreachable", canRead, canWrite };
+  }
+  if (!state.inSyncNodeIds.includes(nodeId)) {
+    return { state: "degraded", reason: "lagging", canRead, canWrite };
+  }
+  return { state: "healthy", reason: "in-sync", canRead, canWrite };
+}
+
 // src/replication/engine/sender-loop.ts
 var SenderLoop = class {
   constructor(engine) {
@@ -1952,6 +1796,24 @@ async function delayAckIfConfigured(engine) {
 }
 
 // src/replication/engine/transport-wiring.ts
+function replicatesFrom(engine, peer) {
+  if (engine.isCoordinatorMode()) {
+    return engine.coordinatorState?.currentPrimary?.nodeId === peer.id;
+  }
+  return engine.config.topology.shouldAcceptFrom(peer.id, peer.role);
+}
+function servesItsData(phase) {
+  return phase === "ready" || phase === "catching-up";
+}
+async function reportAppliedPosition(engine, peer, appliedSeq) {
+  if (appliedSeq === 0n || !replicatesFrom(engine, peer)) return;
+  if (!servesItsData(engine.syncState.phase)) return;
+  if (!servesItsData((await engine.log.getSyncState()).phase)) return;
+  await engine.config.transport.sendAck(
+    peer.id,
+    engine.decorateAck({ batchId: "", ackedSeq: appliedSeq, nodeId: engine.nodeId })
+  );
+}
 function persistAckProgress(engine, nodeId, ackedSeq) {
   engine.log.setLastAppliedSeq(nodeId, ackedSeq).then(() => engine.handleCoordinatorAckProgress(nodeId, ackedSeq)).catch((err) => {
     const wrappedErr = err instanceof Error ? err : new Error(String(err));
@@ -2073,6 +1935,7 @@ function wireTransportHandlers(engine) {
       engine.peerTracker.onAckReceived(peer.id, ackedSeq);
       await engine.log.setLastAppliedSeq(peer.id, ackedSeq);
       await engine.handleCoordinatorAckProgress(peer.id, ackedSeq);
+      await reportAppliedPosition(engine, peer, ackedSeq);
     }).catch((err) => {
       const wrappedErr = err instanceof Error ? err : new Error(String(err));
       engine.emitError({ error: wrappedErr, operation: "peer-state-initialise", peerId: peer.id, recoverable: true });
@@ -2090,11 +1953,12 @@ function wireTransportHandlers(engine) {
     if (engine.syncState.phase === "syncing" && engine.syncState.sourcePeerId === peerId) {
       engine.syncState.phase = "pending";
       engine.syncState.sourcePeerId = null;
-      engine.writerConn.exec("PRAGMA foreign_keys = ON").catch((err) => {
+      setForeignKeysEnabled(engine.writerConn, true).catch((err) => {
         const wrappedErr = err instanceof Error ? err : new Error(String(err));
         engine.emitError({ error: wrappedErr, operation: "peer-disconnect-pragma-restore", peerId, recoverable: false });
       });
       engine.expectedBatchIndex.clear();
+      engine.syncTableDigests.clear();
       engine.log.setSyncMeta("pending").catch((err) => {
         const wrappedErr = err instanceof Error ? err : new Error(String(err));
         engine.emitError({ error: wrappedErr, operation: "sync-meta-write", peerId, recoverable: false });
@@ -2118,6 +1982,10 @@ function wireTransportHandlers(engine) {
   });
   engine.config.transport.onSyncAckReceived((ack, fromPeerId) => {
     if (!engine.running) return;
+    if (engine.syncJoiner.isSourceRejection(ack, fromPeerId)) {
+      engine.syncJoiner.handleSourceRejection(ack, fromPeerId);
+      return;
+    }
     if (!engine.isCoordinatorMode()) {
       if (ack.joinerNodeId !== fromPeerId) {
         engine.emitError({
@@ -2145,6 +2013,10 @@ function wireTransportHandlers(engine) {
 
 // src/replication/engine/startup.ts
 async function recoverHlcFromDurableState(engine) {
+  const persisted = await loadPersistedHlc(engine.writerConn);
+  if (persisted !== null) {
+    engine.hlc.receive(persisted);
+  }
   const maxObserved = await engine.log.recoverMaxObservedHlc();
   if (maxObserved === null) return;
   engine.hlc.receive(maxObserved);
@@ -2170,8 +2042,8 @@ async function startEngine(engine) {
   await engine.config.transport.connect(engine.nodeId, transportConfig);
   const isPrimary = engine.isCoordinatorMode() ? engine.hasCoordinatorWriteAuthority() : engine.config.topology.role === "primary";
   const syncCompleted = await engine.log.isSyncCompleted();
-  const requiresCoordinatorRejoinSync = engine.requiresCoordinatorRejoinSync();
-  if (engine.initialSync && !isPrimary && (!syncCompleted || requiresCoordinatorRejoinSync)) {
+  const requiresCoordinatorRejoinSync2 = engine.requiresCoordinatorRejoinSync();
+  if (engine.initialSync && !isPrimary && (!syncCompleted || requiresCoordinatorRejoinSync2)) {
     const savedState = await engine.log.getSyncState();
     if (savedState.phase === "syncing") {
       if (!engine.tracker) {
@@ -2229,11 +2101,135 @@ async function startEngine(engine) {
   }
   engine.startSenderLoop();
 }
+
+// src/replication/engine/sync-recovery.ts
+var SYNC_RETRY_MIN_DELAY_MS = 1e3;
+var SYNC_RETRY_MAX_DELAY_MS = 3e4;
+function unreffed(timer) {
+  const unreffable = timer;
+  unreffable.unref?.();
+  return unreffable;
+}
+var SyncRecovery = class {
+  constructor(engine, retryAttempt) {
+    this.engine = engine;
+    this.retryAttempt = retryAttempt;
+  }
+  activeRequestId = null;
+  responseTimer = null;
+  retryTimer = null;
+  retryDelayMs = SYNC_RETRY_MIN_DELAY_MS;
+  markRequestSent(requestId, sourcePeerId) {
+    this.activeRequestId = requestId;
+    this.clearResponseTimer();
+    this.responseTimer = unreffed(
+      setTimeout(() => {
+        this.responseTimer = null;
+        if (!this.engine.running || this.activeRequestId !== requestId) return;
+        const reason = `The sync source sent no data within ${this.engine.syncAckTimeoutMs}ms`;
+        this.report(reason, requestId, "sync-response-timeout", sourcePeerId);
+        void this.abandonAndRetry(reason);
+      }, this.engine.syncAckTimeoutMs)
+    );
+  }
+  markRequestFailed() {
+    this.activeRequestId = null;
+    this.clearResponseTimer();
+    this.scheduleRetry();
+  }
+  noteSourceResponded(requestId) {
+    if (requestId !== this.activeRequestId) return;
+    this.clearResponseTimer();
+  }
+  markSyncReady() {
+    this.activeRequestId = null;
+    this.clearResponseTimer();
+    this.cancelRetry();
+    this.retryDelayMs = SYNC_RETRY_MIN_DELAY_MS;
+  }
+  isSourceRejection(ack, fromPeerId) {
+    const engine = this.engine;
+    return ack.success === false && this.activeRequestId !== null && ack.requestId === this.activeRequestId && ack.joinerNodeId === engine.nodeId && engine.syncState.phase === "syncing" && engine.syncState.sourcePeerId === fromPeerId;
+  }
+  handleSourceRejection(ack, fromPeerId) {
+    const reason = ack.error ?? "The sync source refused the request";
+    this.report(reason, ack.requestId, "sync-refused", fromPeerId);
+    void this.abandonAndRetry(reason);
+  }
+  stop() {
+    this.clearResponseTimer();
+    this.cancelRetry();
+  }
+  report(reason, requestId, operation, peerId) {
+    this.engine.emitError({ error: new SyncError(reason, requestId), operation, peerId, recoverable: true });
+  }
+  async abandonAndRetry(reason) {
+    this.activeRequestId = null;
+    this.clearResponseTimer();
+    await abandonActiveSync(this.engine, reason);
+    if (!this.engine.running) return;
+    this.scheduleRetry();
+  }
+  scheduleRetry() {
+    this.cancelRetry();
+    this.retryTimer = unreffed(
+      setTimeout(() => {
+        this.retryTimer = null;
+        this.retryAttempt();
+      }, this.retryDelayMs)
+    );
+    this.retryDelayMs = Math.min(this.retryDelayMs * 2, SYNC_RETRY_MAX_DELAY_MS);
+  }
+  cancelRetry() {
+    if (this.retryTimer === null) return;
+    clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  clearResponseTimer() {
+    if (this.responseTimer === null) return;
+    clearTimeout(this.responseTimer);
+    this.responseTimer = null;
+  }
+};
+async function abandonActiveSync(engine, reason) {
+  engine.syncState.phase = "pending";
+  engine.syncState.sourcePeerId = null;
+  engine.syncState.startedAt = null;
+  engine.syncState.error = reason;
+  engine.expectedBatchIndex.clear();
+  engine.syncTableDigests.clear();
+  try {
+    await setForeignKeysEnabled(engine.writerConn, true);
+  } catch (err) {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "sync-abandon-pragma-restore", recoverable: false });
+  }
+  try {
+    await engine.log.setSyncMeta("pending");
+  } catch (err) {
+    const wrappedErr = err instanceof Error ? err : new Error(String(err));
+    engine.emitError({ error: wrappedErr, operation: "sync-meta-write", recoverable: false });
+  }
+}
+function advanceStreamDigest(previous, batchChecksum, rowsInBatch) {
+  const digest = createHash("sha256").update(previous?.digest ?? "").update(batchChecksum).digest("hex");
+  return { rowCount: (previous?.rowCount ?? 0) + rowsInBatch, digest };
+}
+function matchesStreamDigest(manifest, local) {
+  if (manifest.batchDigest === void 0 || local === void 0) return false;
+  return local.rowCount === manifest.rowCount && local.digest === manifest.batchDigest;
+}
+
+// src/replication/engine/sync-joiner.ts
 var SyncJoiner = class {
   constructor(engine) {
     this.engine = engine;
+    this.recovery = new SyncRecovery(engine, () => {
+      this.retryInitiateSync();
+    });
   }
   catchUpCheckTimer = null;
+  recovery;
   async initiateSync() {
     const engine = this.engine;
     if (engine.syncState.phase !== "pending") return;
@@ -2270,17 +2266,21 @@ var SyncJoiner = class {
       const savedState = await engine.log.getSyncState();
       const completedTables = savedState.phase === "pending" ? [] : savedState.completedTables;
       const requestId = randomUUID();
+      engine.syncTableDigests.clear();
       await engine.log.setSyncMeta("syncing", void 0, sourcePeerId, requestId);
       await engine.config.transport.requestSync(
         sourcePeerId,
         engine.decorateSyncRequest({
           requestId,
           joinerNodeId: engine.nodeId,
-          completedTables
+          completedTables,
+          supportsStreamVerification: true
         })
       );
+      this.recovery.markRequestSent(requestId, sourcePeerId);
     } catch (err) {
       const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      this.recovery.markRequestFailed();
       if (engine.syncState.phase === "syncing" && engine.syncState.sourcePeerId === sourcePeerId) {
         engine.syncState.phase = "pending";
         engine.syncState.sourcePeerId = null;
@@ -2305,6 +2305,7 @@ var SyncJoiner = class {
     const engine = this.engine;
     if (engine.syncState.phase !== "syncing") return;
     if (fromPeerId !== engine.syncState.sourcePeerId) return;
+    this.recovery.noteSourceResponded(batch.requestId);
     if (!engine.tracker) {
       throw new SyncError("Initial sync requires a ChangeTracker in ReplicationConfig");
     }
@@ -2332,7 +2333,7 @@ var SyncJoiner = class {
               throw new SyncError(`Unsafe DDL in schema batch: ${ddl}`);
             }
           }
-          await engine.writerConn.exec("PRAGMA foreign_keys = OFF");
+          await setForeignKeysEnabled(engine.writerConn, false);
           for (const ddl of batch.schema) {
             let saferDdl = ddl.replace(/^\s*CREATE\s+TABLE\b/i, "CREATE TABLE IF NOT EXISTS");
             saferDdl = saferDdl.replace(/^\s*CREATE\s+INDEX\b/i, "CREATE INDEX IF NOT EXISTS");
@@ -2348,7 +2349,7 @@ var SyncJoiner = class {
         });
         return;
       }
-      if (!IDENTIFIER_RE.test(batch.table)) {
+      if (!IDENTIFIER_RE2.test(batch.table)) {
         throw new SyncError(`Invalid table name in sync batch: ${batch.table}`);
       }
       const expectedChecksum = createHash("sha256").update(canonicaliseForChecksum(batch.rows)).digest("hex");
@@ -2356,24 +2357,42 @@ var SyncJoiner = class {
         throw new SyncError(`Checksum mismatch for ${batch.table} batch ${batch.batchIndex}`);
       }
       if (batch.batchIndex === 0 && !engine.syncState.completedTables.includes(batch.table)) {
+        engine.syncTableDigests.delete(batch.table);
         await engine.tracker.unwatch(engine.writerConn, batch.table);
         await engine.writerConn.exec(`DELETE FROM "${batch.table}"`);
       }
       if (batch.rows.length > 0) {
-        const columns = Object.keys(batch.rows[0]).filter((c) => IDENTIFIER_RE.test(c));
-        if (columns.length > 0) {
-          const placeholders = columns.map(() => "?").join(", ");
-          const colNames = columns.map((c) => `"${c}"`).join(", ");
-          const insertSql = `INSERT INTO "${batch.table}" (${colNames}) VALUES (${placeholders})`;
-          await engine.writerConn.transaction(async (tx) => {
-            const stmt = await tx.prepare(insertSql);
-            for (const row of batch.rows) {
-              const values = columns.map((c) => row[c]);
-              await stmt.run(...values);
-            }
-          });
+        const columns = Object.keys(batch.rows[0]);
+        if (columns.length === 0) {
+          throw new SyncError(`No columns in sync batch for ${batch.table}`);
+        }
+        for (const col of columns) {
+          if (!IDENTIFIER_RE2.test(col)) {
+            throw new SyncError(`Invalid column name '${col}' in sync batch for ${batch.table}`);
+          }
         }
+        const columnSet = new Set(columns);
+        for (const row of batch.rows) {
+          const keys = Object.keys(row);
+          if (keys.length !== columns.length || keys.some((k) => !columnSet.has(k))) {
+            throw new SyncError(`Row columns do not match batch columns for ${batch.table}`);
+          }
+        }
+        const placeholders = columns.map(() => "?").join(", ");
+        const colNames = columns.map((c) => `"${c}"`).join(", ");
+        const insertSql = `INSERT INTO "${batch.table}" (${colNames}) VALUES (${placeholders})`;
+        await engine.writerConn.transaction(async (tx) => {
+          const stmt = await tx.prepare(insertSql);
+          for (const row of batch.rows) {
+            const values = columns.map((c) => row[c]);
+            await stmt.run(...values);
+          }
+        });
       }
+      engine.syncTableDigests.set(
+        batch.table,
+        advanceStreamDigest(engine.syncTableDigests.get(batch.table), batch.checksum, batch.rows.length)
+      );
       if (batch.isLastBatchForTable) {
         await engine.log.setSyncTableStatus(batch.table, "completed");
         engine.syncState.completedTables.push(batch.table);
@@ -2411,31 +2430,31 @@ var SyncJoiner = class {
     }
     try {
       for (const manifest of complete.manifests) {
-        if (IDENTIFIER_RE.test(manifest.table)) {
+        if (IDENTIFIER_RE2.test(manifest.table)) {
           await engine.tracker.watch(engine.writerConn, manifest.table);
         }
       }
-      await engine.writerConn.exec("PRAGMA foreign_keys = ON");
+      await setForeignKeysEnabled(engine.writerConn, true);
       for (const manifest of complete.manifests) {
-        const valid = await engine.log.verifyManifest(manifest);
+        const valid = manifest.batchDigest !== void 0 ? matchesStreamDigest(manifest, engine.syncTableDigests.get(manifest.table)) : await engine.log.verifyManifest(manifest);
         if (!valid) {
           await engine.log.wipeTables(
             engine.writerConn,
-            complete.manifests.map((m) => m.table).filter((t) => IDENTIFIER_RE.test(t)),
+            complete.manifests.map((m) => m.table).filter((t) => IDENTIFIER_RE2.test(t)),
             engine.tracker
           );
           engine.syncState.phase = "pending";
           engine.syncState.completedTables = [];
           engine.expectedBatchIndex.clear();
+          engine.syncTableDigests.clear();
           await engine.log.setSyncMeta("pending");
           await this.initiateSync();
           return;
         }
       }
+      engine.syncTableDigests.clear();
       await engine.log.setLastAppliedSeq(fromPeerId, complete.snapshotSeq);
-      const recordStmt = await engine.writerConn.prepare(
-        `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
-      );
+      const recordStmt = await prepareInsertAppliedChange(engine.writerConn);
       await recordStmt.run(fromPeerId, complete.snapshotSeq.toString(), Date.now() / 1e3);
       const previousApplied = engine.appliedSeqByPeer.get(fromPeerId) ?? 0n;
       if (complete.snapshotSeq > previousApplied) {
@@ -2448,7 +2467,7 @@ var SyncJoiner = class {
       this.startCatchUpCheck();
     } catch {
       try {
-        await engine.writerConn.exec("PRAGMA foreign_keys = ON");
+        await setForeignKeysEnabled(engine.writerConn, true);
       } catch (pragmaErr) {
         const wrappedErr = pragmaErr instanceof Error ? pragmaErr : new Error(String(pragmaErr));
         engine.emitError({ error: wrappedErr, operation: "sync-complete-pragma-restore", recoverable: false });
@@ -2501,6 +2520,23 @@ var SyncJoiner = class {
       this.catchUpCheckTimer = null;
     }
   }
+  stopTimers() {
+    this.stopCatchUpCheck();
+    this.recovery.stop();
+  }
+  isSourceRejection(ack, fromPeerId) {
+    return this.recovery.isSourceRejection(ack, fromPeerId);
+  }
+  handleSourceRejection(ack, fromPeerId) {
+    this.recovery.handleSourceRejection(ack, fromPeerId);
+  }
+  retryInitiateSync() {
+    if (!this.engine.running) return;
+    this.initiateSync().catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      this.engine.emitError({ error: wrappedErr, operation: "sync-retry", recoverable: true });
+    });
+  }
   async sendSyncAck(peerId, ack) {
     await delayAckIfConfigured(this.engine);
     await this.engine.config.transport.sendSyncAck(peerId, this.engine.decorateSyncAck(ack));
@@ -2510,6 +2546,7 @@ var SyncJoiner = class {
     await engine.log.setSyncMeta("ready");
     await engine.markCoordinatorSyncReady();
     engine.syncState.phase = "ready";
+    this.recovery.markSyncReady();
     this.stopCatchUpCheck();
   }
 };
@@ -2519,6 +2556,19 @@ var SyncServer = class {
   }
   activeSyncs = /* @__PURE__ */ new Map();
   syncAckWaiters = /* @__PURE__ */ new Map();
+  async rejectSyncRequest(fromPeerId, request, error) {
+    await this.engine.config.transport.sendSyncAck(
+      fromPeerId,
+      this.engine.decorateSyncAck({
+        requestId: request.requestId,
+        joinerNodeId: request.joinerNodeId,
+        table: "__schema__",
+        batchIndex: -1,
+        success: false,
+        error
+      })
+    );
+  }
   async handleSyncRequest(request, fromPeerId) {
     const engine = this.engine;
     const knownPeers = engine.config.transport.peers();
@@ -2528,88 +2578,28 @@ var SyncServer = class {
         await engine.verifyPrimaryAuthority();
       } catch (err) {
         const wrappedErr = err instanceof Error ? err : new Error(String(err));
-        await engine.config.transport.sendSyncAck(
-          fromPeerId,
-          engine.decorateSyncAck({
-            requestId: request.requestId,
-            joinerNodeId: request.joinerNodeId,
-            table: "__schema__",
-            batchIndex: -1,
-            success: false,
-            error: wrappedErr.message
-          })
-        );
+        await this.rejectSyncRequest(fromPeerId, request, wrappedErr.message);
         return;
       }
     } else if (!engine.config.topology.canWrite()) {
-      await engine.config.transport.sendSyncAck(
-        fromPeerId,
-        engine.decorateSyncAck({
-          requestId: request.requestId,
-          joinerNodeId: request.joinerNodeId,
-          table: "__schema__",
-          batchIndex: -1,
-          success: false,
-          error: "This node cannot serve syncs"
-        })
-      );
+      await this.rejectSyncRequest(fromPeerId, request, "This node cannot serve syncs");
       return;
     }
     if (this.activeSyncs.has(request.requestId)) {
-      await engine.config.transport.sendSyncAck(
-        fromPeerId,
-        engine.decorateSyncAck({
-          requestId: request.requestId,
-          joinerNodeId: request.joinerNodeId,
-          table: "__schema__",
-          batchIndex: -1,
-          success: false,
-          error: "Duplicate requestId"
-        })
-      );
+      await this.rejectSyncRequest(fromPeerId, request, "Duplicate requestId");
       return;
     }
     if (this.activeSyncs.size >= engine.maxConcurrentSyncs) {
-      await engine.config.transport.sendSyncAck(
-        fromPeerId,
-        engine.decorateSyncAck({
-          requestId: request.requestId,
-          joinerNodeId: request.joinerNodeId,
-          table: "__schema__",
-          batchIndex: -1,
-          success: false,
-          error: "Sync capacity reached, retry later"
-        })
-      );
+      await this.rejectSyncRequest(fromPeerId, request, "Sync capacity reached, retry later");
       return;
     }
     if (!engine.snapshotConnectionFactory) {
-      await engine.config.transport.sendSyncAck(
-        fromPeerId,
-        engine.decorateSyncAck({
-          requestId: request.requestId,
-          joinerNodeId: request.joinerNodeId,
-          table: "__schema__",
-          batchIndex: -1,
-          success: false,
-          error: "No snapshot connection factory configured"
-        })
-      );
+      await this.rejectSyncRequest(fromPeerId, request, "No snapshot connection factory configured");
       return;
     }
     for (const table of request.completedTables) {
-      if (!IDENTIFIER_RE.test(table)) {
-        await engine.config.transport.sendSyncAck(
-          fromPeerId,
-          engine.decorateSyncAck({
-            requestId: request.requestId,
-            joinerNodeId: request.joinerNodeId,
-            table: "__schema__",
-            batchIndex: -1,
-            success: false,
-            error: `Invalid table name in completedTables: ${table}`
-          })
-        );
+      if (!IDENTIFIER_RE2.test(table)) {
+        await this.rejectSyncRequest(fromPeerId, request, `Invalid table name in completedTables: ${table}`);
         return;
       }
     }
@@ -2617,16 +2607,10 @@ var SyncServer = class {
     try {
       readConn = await engine.snapshotConnectionFactory();
     } catch (err) {
-      await engine.config.transport.sendSyncAck(
+      await this.rejectSyncRequest(
         fromPeerId,
-        engine.decorateSyncAck({
-          requestId: request.requestId,
-          joinerNodeId: request.joinerNodeId,
-          table: "__schema__",
-          batchIndex: -1,
-          success: false,
-          error: `Failed to open snapshot connection: ${err instanceof Error ? err.message : String(err)}`
-        })
+        request,
+        `Failed to open snapshot connection: ${err instanceof Error ? err.message : String(err)}`
       );
       return;
     }
@@ -2653,7 +2637,9 @@ var SyncServer = class {
       completedTables: new Set(request.completedTables),
       startedAt: Date.now(),
       timeoutTimer,
-      aborted: false
+      aborted: false,
+      streamVerification: request.supportsStreamVerification === true,
+      tableDigests: /* @__PURE__ */ new Map()
     };
     this.activeSyncs.set(request.requestId, session);
     this.serveSyncSession(session).catch((err) => {
@@ -2764,6 +2750,15 @@ var SyncServer = class {
     }
     return ackPromise;
   }
+  refreshSessionDeadline(session) {
+    clearTimeout(session.timeoutTimer);
+    const timer = setTimeout(
+      () => this.abortSyncSession(session.requestId),
+      this.engine.maxSyncDurationMs
+    );
+    timer.unref?.();
+    session.timeoutTimer = timer;
+  }
   async serveSyncSession(session) {
     const engine = this.engine;
     const schemaDdl = await engine.log.dumpSchema(session.readConn);
@@ -2782,6 +2777,7 @@ var SyncServer = class {
       this.abortSyncSession(session.requestId);
       return;
     }
+    this.refreshSessionDeadline(session);
     for (const table of session.tables) {
       if (session.aborted) return;
       let batchIndex = 0;
@@ -2803,28 +2799,41 @@ var SyncServer = class {
           this.abortSyncSession(session.requestId);
           return;
         }
+        this.refreshSessionDeadline(session);
+        session.tableDigests.set(table, advanceStreamDigest(session.tableDigests.get(table), checksum, rows.length));
         batchIndex += 1;
       }
       if (batchIndex === 0) {
+        const emptyChecksum = createHash("sha256").update(canonicaliseForChecksum([])).digest("hex");
         const emptyAck = await this.sendSyncBatchAndWaitForAck(session.joinerNodeId, {
           requestId: session.requestId,
           table,
           batchIndex: 0,
           rows: [],
-          checksum: createHash("sha256").update(canonicaliseForChecksum([])).digest("hex"),
+          checksum: emptyChecksum,
           isLastBatchForTable: true
         });
         if (!emptyAck.success) {
           this.abortSyncSession(session.requestId);
           return;
         }
+        this.refreshSessionDeadline(session);
+        session.tableDigests.set(table, advanceStreamDigest(void 0, emptyChecksum, 0));
       }
       session.completedTables.add(table);
     }
     if (session.aborted) return;
     const manifests = [];
     for (const table of session.tables) {
-      manifests.push(await engine.log.generateManifest(session.readConn, table));
+      if (session.streamVerification) {
+        const streamDigest = session.tableDigests.get(table);
+        if (!streamDigest) {
+          throw new SyncError(`Missing stream digest for table ${table}`, session.requestId);
+        }
+        manifests.push({ table, rowCount: streamDigest.rowCount, batchDigest: streamDigest.digest });
+      } else {
+        manifests.push(await engine.log.generateManifest(session.readConn, table));
+      }
     }
     await engine.config.transport.sendSyncComplete(
       session.joinerNodeId,
@@ -2863,9 +2872,6 @@ var SyncServer = class {
 };
 
 // src/replication/engine/engine.ts
-var DEFAULT_COORDINATOR_SESSION_TTL_MS = 1e4;
-var DEFAULT_CONTROLLER_LEASE_TTL_MS = 1e4;
-var DEFAULT_CONTROLLER_TICK_INTERVAL_MS = 1e3;
 var ReplicationEngine = class extends EventEmitter {
   database;
   writerConn;
@@ -2901,11 +2907,16 @@ var ReplicationEngine = class extends EventEmitter {
   coordinatorLeaseTimer = null;
   controllerTimer = null;
   coordinatorRejoinSyncStarting = false;
+  coordinatorSessionRestoring = false;
+  coordinatorLastContactMs = 0;
+  inSyncReconcileTimer = null;
+  inSyncReconciling = false;
   lastSentSeq = 0n;
   lastLocalSeq = 0n;
   highestSourceSeqSeen = 0n;
   appliedSeqByPeer = /* @__PURE__ */ new Map();
   expectedBatchIndex = /* @__PURE__ */ new Map();
+  syncTableDigests = /* @__PURE__ */ new Map();
   syncState = {
     phase: "ready",
     sourcePeerId: null,
@@ -2959,12 +2970,12 @@ var ReplicationEngine = class extends EventEmitter {
   async stop() {
     if (!this.running) return;
     this.running = false;
-    this.stopCoordinatorTimers();
-    this.syncJoiner.stopCatchUpCheck();
+    stopCoordinatorTimers(this);
+    this.syncJoiner.stopTimers();
     this.syncServer.abortAll();
     if (this.syncState.phase === "syncing") {
       try {
-        await this.writerConn.exec("PRAGMA foreign_keys = ON");
+        await setForeignKeysEnabled(this.writerConn, true);
       } catch (err) {
         const wrappedErr = err instanceof Error ? err : new Error(String(err));
         this.emitError({ error: wrappedErr, operation: "engine-stop-pragma-restore", recoverable: false });
@@ -2974,18 +2985,19 @@ var ReplicationEngine = class extends EventEmitter {
     if (this.tracker) {
       this.tracker.clearPruneBoundary();
     }
-    await this.stopCoordinatorMode();
+    await stopCoordinatorMode(this);
     await this.config.transport.disconnect();
   }
   status() {
     return {
       nodeId: this.nodeId,
-      role: this.config.topology.role,
+      role: effectiveTopologyRole(this),
       peers: this.peerTracker.allPeerStates(),
       localSeq: this.lastSentSeq,
       replicating: this.running,
+      health: computeNodeHealth(this),
       syncState: { ...this.syncState },
-      coordinator: this.getCoordinatorRuntimeStatus()
+      coordinator: getCoordinatorRuntimeStatus(this)
     };
   }
   getCurrentSeq() {
@@ -2994,77 +3006,20 @@ var ReplicationEngine = class extends EventEmitter {
   getAppliedSeq(peerId) {
     return this.appliedSeqByPeer.get(peerId) ?? 0n;
   }
-  async query(sql, params, options) {
-    if (this.syncState.phase !== "ready") {
-      throw new SyncError(`Node is in '${this.syncState.phase}' phase and cannot serve reads`);
-    }
-    await this.assertReadConcern(options?.readConcern?.level);
-    return this.database.query(sql, params, options);
+  query(sql, params, options) {
+    return query(this, sql, params, options);
   }
-  async execute(sql, params, options) {
-    if (this.syncState.phase !== "ready") {
-      throw new SyncError(`Node is in '${this.syncState.phase}' phase and cannot accept operations`);
-    }
-    if (!await this.canAcceptLocalWrite()) {
-      if (this.config.writeForwarding) {
-        const result = await this.forwardStatements([{ sql, params }], options);
-        const first = result.results[0];
-        if (!first) {
-          return { changes: 0, lastInsertRowId: 0 };
-        }
-        return {
-          changes: first.changes,
-          lastInsertRowId: typeof first.lastInsertRowId === "string" ? BigInt(first.lastInsertRowId) : first.lastInsertRowId
-        };
-      }
-      this.throwNotCurrentPrimary();
-    }
-    return this.localExecutor.executeLocally(sql, params, options);
+  execute(sql, params, options) {
+    return execute(this, sql, params, options);
   }
-  async executeBatch(sql, paramsBatch, options) {
-    if (this.syncState.phase !== "ready") {
-      throw new SyncError(`Node is in '${this.syncState.phase}' phase and cannot accept operations`);
-    }
-    if (!await this.canAcceptLocalWrite()) {
-      if (this.config.writeForwarding) {
-        const statements = paramsBatch.map((p) => ({ sql, params: p }));
-        const result = await this.forwardStatements(statements, options);
-        return result.results.map((r) => ({
-          changes: r.changes,
-          lastInsertRowId: typeof r.lastInsertRowId === "string" ? BigInt(r.lastInsertRowId) : Number(r.lastInsertRowId)
-        }));
-      }
-      this.throwNotCurrentPrimary();
-    }
-    const results = [];
-    for (const params of paramsBatch) {
-      const r = await this.localExecutor.executeLocally(sql, params, options);
-      results.push(r);
-    }
-    return results;
+  executeBatch(sql, paramsBatch, options) {
+    return executeBatch(this, sql, paramsBatch, options);
   }
-  async transaction(fn, options) {
-    if (this.syncState.phase !== "ready") {
-      throw new SyncError(`Node is in '${this.syncState.phase}' phase and cannot accept operations`);
-    }
-    if (!await this.canAcceptLocalWrite()) {
-      throw new TopologyError("This node cannot accept writes in transaction mode");
-    }
-    return this.localExecutor.executeTransactionLocally(fn, options);
+  transaction(fn, options) {
+    return transaction(this, fn, options);
   }
-  async forwardStatements(statements, _options) {
-    if (await this.canAcceptLocalWrite()) {
-      return this.localExecutor.executeForwardedLocally(statements);
-    }
-    const primaryPeerId = this.getForwardingPrimaryPeerId();
-    if (primaryPeerId === null) {
-      throw new TopologyError("No primary node available for write forwarding");
-    }
-    return this.config.transport.forward(primaryPeerId, {
-      statements,
-      requestId: randomUUID(),
-      ...this.getCoordinatorMessageFields()
-    });
+  forwardStatements(statements, options) {
+    return forwardStatements(this, statements);
   }
   startSenderLoop() {
     this.senderLoop.start();
@@ -3098,240 +3053,61 @@ var ReplicationEngine = class extends EventEmitter {
       }
     }
   }
-  async waitForWriteConcern(seq, wc) {
-    const timeout = wc.timeoutMs ?? 5e3;
-    if (this.isCoordinatorMode()) {
-      const state = this.coordinatorState ?? await this.refreshCoordinatorState();
-      if (!state) {
-        throw new CoordinatorError("Cannot satisfy write concern without replication-group state");
-      }
-      if (wc.level === "majority") {
-        await this.peerTracker.waitForConfiguredMajority(seq, this.nodeId, state.votingDataBearingNodeIds, timeout);
-        await this.updateCoordinatorProgressAfterWrite(seq, state);
-      } else if (wc.level === "all") {
-        const eligibleVoters = state.votingDataBearingNodeIds.filter((nodeId) => !state.drainingNodeIds.includes(nodeId));
-        await this.peerTracker.waitForConfiguredAll(seq, this.nodeId, eligibleVoters, timeout);
-        await this.updateCoordinatorProgressAfterWrite(seq, state);
-      }
-      return;
-    }
-    if (wc.level === "majority") {
-      await this.peerTracker.waitForMajority(seq, timeout);
-    } else if (wc.level === "all") {
-      await this.peerTracker.waitForAll(seq, timeout);
-    }
+  waitForWriteConcern(seq, wc) {
+    return waitForWriteConcern(this, seq, wc);
   }
   async loadAppliedSeqs() {
-    const stmt = await this.writerConn.prepare(
-      `SELECT source_node_id, MAX(source_seq) AS max_seq FROM ${APPLIED_CHANGES_TABLE} GROUP BY source_node_id`
-    );
-    const rows = await stmt.all();
-    for (const row of rows) {
-      if (row.max_seq === null) continue;
-      this.appliedSeqByPeer.set(row.source_node_id, BigInt(row.max_seq));
+    for (const [nodeId, seq] of await selectMaxAppliedSourceSeqByNode(this.writerConn)) {
+      this.appliedSeqByPeer.set(nodeId, seq);
     }
   }
   isCoordinatorMode() {
     return this.config.coordinator !== void 0;
   }
-  async startCoordinatorMode() {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const coordinator = config.coordinator;
-    let state = await coordinator.getReplicationGroupState(config.clusterId, config.groupId);
-    if (!state && config.votingDataBearingNodeIds) {
-      state = await coordinator.setReplicationGroupState({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        votingDataBearingNodeIds: config.votingDataBearingNodeIds,
-        currentPrimary: this.config.topology.role === "primary" ? this.localCoordinatorPrimary() : null,
-        primaryTerm: 1n,
-        inSyncNodeIds: [this.nodeId],
-        compatibility: config.compatibility
-      });
-    }
-    if (!state) {
-      throw new CoordinatorError(`Replication group '${config.groupId}' is not registered`);
-    }
-    this.coordinatorState = state;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(state);
-    const session = await coordinator.registerNodeSession({
-      clusterId: config.clusterId,
-      nodeId: this.nodeId,
-      ttlMs: config.sessionTtlMs ?? DEFAULT_COORDINATOR_SESSION_TTL_MS,
-      endpoint: config.endpoint,
-      groupIds: [config.groupId],
-      dataBearing: true,
-      voting: state.votingDataBearingNodeIds.includes(this.nodeId),
-      compatibility: config.compatibility
-    });
-    this.nodeSessionLeaseId = session.lease.id;
-    this.coordinatorWatchDisposer = await coordinator.watchReplicationGroup(config.clusterId, config.groupId, (next) => {
-      this.handleCoordinatorStateUpdate(next);
-    });
-    this.startCoordinatorLeaseRenewal();
-    this.startControllerLoop();
+  startCoordinatorMode() {
+    return startCoordinatorMode(this);
   }
-  async prepareCoordinatorRejoinIfNeeded() {
-    const state = this.coordinatorState ?? await this.refreshCoordinatorState();
-    if (!state || !this.requiresCoordinatorRejoin(state)) return;
-    await this.evaluateFormerPrimaryHistory(state);
+  prepareCoordinatorRejoinIfNeeded() {
+    return prepareCoordinatorRejoinIfNeeded(this);
   }
   hasCoordinatorWriteAuthority() {
     return this.coordinatorAuthority;
   }
   requiresCoordinatorRejoinSync(state = this.coordinatorState) {
-    if (!state || state.currentPrimary?.nodeId === this.nodeId) return false;
-    if (state.faultedNodeIds.includes(this.nodeId)) return false;
-    return state.repairingNodeIds.includes(this.nodeId);
-  }
-  async markCoordinatorSyncReady() {
-    const config = this.config.coordinator;
-    const state = this.coordinatorState ?? await this.refreshCoordinatorState();
-    if (!config || !state || state.currentPrimary?.nodeId === this.nodeId) return;
-    if (!state.votingDataBearingNodeIds.includes(this.nodeId)) return;
-    if (state.faultedNodeIds.includes(this.nodeId)) return;
-    if (state.drainingNodeIds.includes(this.nodeId)) {
-      await this.removeLocalNodeFromCoordinatorInSyncSet(state);
-      return;
-    }
-    const needsAdmission = !state.inSyncNodeIds.includes(this.nodeId) || state.repairingNodeIds.includes(this.nodeId);
-    if (!needsAdmission) {
-      this.coordinatorState = state;
-      this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(state);
-      return;
-    }
-    const sourceNodeId = state.currentPrimary?.nodeId;
-    if (!sourceNodeId || this.syncState.sourcePeerId !== sourceNodeId) {
-      this.coordinatorState = state;
-      this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(state);
-      return;
-    }
-    const appliedSeq = await this.log.getLastAppliedSeq(sourceNodeId);
-    if (appliedSeq < state.durabilityPointSeq) {
-      this.coordinatorState = state;
-      this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(state);
-      return;
-    }
-    const admitted = await config.coordinator.admitNodeToInSyncSet({
-      clusterId: config.clusterId,
-      groupId: config.groupId,
-      nodeId: this.nodeId,
-      sourceNodeId,
-      appliedSeq
-    });
-    this.coordinatorState = admitted ?? state;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(this.coordinatorState);
-  }
-  async handleCoordinatorAckProgress(nodeId, ackedSeq) {
-    const config = this.config.coordinator;
-    const state = this.coordinatorState;
-    if (!config || !state) return;
-    if (nodeId === this.nodeId) return;
-    if (!this.hasCurrentPrimaryAuthorityFor(state)) return;
-    if (state.inSyncNodeIds.includes(nodeId)) return;
-    if (!state.votingDataBearingNodeIds.includes(nodeId)) return;
-    if (ackedSeq < state.durabilityPointSeq) return;
-    const admitted = await config.coordinator.admitNodeToInSyncSet({
-      clusterId: config.clusterId,
-      groupId: config.groupId,
-      nodeId,
-      sourceNodeId: this.nodeId,
-      appliedSeq: ackedSeq
-    });
-    if (!admitted) return;
-    this.coordinatorState = admitted;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(admitted);
-  }
-  async removeLocalNodeFromCoordinatorInSyncSet(state) {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const inSyncNodeIds = state.inSyncNodeIds.filter((nodeId) => nodeId !== this.nodeId);
-    let nextState = state;
-    if (!arraysEqual(inSyncNodeIds, state.inSyncNodeIds)) {
-      const updated = await config.coordinator.updateInSyncSet({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        inSyncNodeIds
-      });
-      if (!updated) {
-        throw new CoordinatorError("Failed to mark repaired node as in sync");
-      }
-      nextState = updated;
-    }
-    this.coordinatorState = nextState;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(this.coordinatorState);
+    return requiresCoordinatorRejoinSync(this, state);
   }
-  async verifyPrimaryAuthority() {
-    const state = await this.refreshCoordinatorState();
-    if (!state) {
-      throw new CoordinatorError("Cannot prove primary authority without replication-group state");
-    }
-    if (!this.hasCurrentPrimaryAuthorityFor(state)) {
-      throw new StalePrimaryError(
-        "Node is not the current primary for this replication group",
-        this.errorDetails(state)
-      );
-    }
-    this.assertLocalCompatibility(state);
-    if (state.drainingNodeIds.includes(this.nodeId)) {
-      throw new NodeDrainingError("Node is draining and cannot accept writes", this.errorDetails(state));
-    }
-    if (state.repairingNodeIds.includes(this.nodeId) || state.faultedNodeIds.includes(this.nodeId)) {
-      throw new AuthorityError(
-        "Node is not eligible to accept writes while repair or fault state is active",
-        "AUTHORITY_LOST",
-        this.errorDetails(state)
-      );
-    }
-    return state;
+  markCoordinatorSyncReady() {
+    return markCoordinatorSyncReady(this);
   }
-  async assertInboundCoordinatorMessage(message, fromPeerId, direction) {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const state = this.coordinatorState ?? await this.refreshCoordinatorState();
-    if (!state) {
-      throw new CoordinatorError("Cannot validate coordinator message without replication-group state");
-    }
-    if (message.groupId !== config.groupId || message.primaryTerm !== state.primaryTerm) {
-      throw new StalePrimaryError(
-        `Rejected ${direction} message for stale or wrong replication group term`,
-        this.errorDetails(state)
-      );
-    }
-    if ((direction === "batch" || direction === "sync-data") && fromPeerId !== state.currentPrimary?.nodeId) {
-      throw new StalePrimaryError(
-        `Rejected ${direction} message from non-current primary '${fromPeerId}'`,
-        this.errorDetails(state)
-      );
-    }
-    if ((direction === "ack" || direction === "forward" || direction === "sync-request") && !this.hasCurrentPrimaryAuthorityFor(state)) {
-      throw new StalePrimaryError(
-        `Rejected ${direction} message because this node is not current primary`,
-        this.errorDetails(state)
-      );
-    }
+  handleCoordinatorAckProgress(nodeId, ackedSeq) {
+    return handleCoordinatorAckProgress(this, nodeId, ackedSeq);
+  }
+  verifyPrimaryAuthority() {
+    return verifyPrimaryAuthority(this);
+  }
+  assertInboundCoordinatorMessage(message, fromPeerId, direction) {
+    return assertInboundCoordinatorMessage(this, message, fromPeerId, direction);
   }
   decorateBatch(batch) {
-    return { ...batch, ...this.getCoordinatorMessageFields() };
+    return { ...batch, ...getCoordinatorMessageFields(this) };
   }
   decorateAck(ack) {
-    return { ...ack, ...this.getCoordinatorMessageFields() };
+    return { ...ack, ...getCoordinatorMessageFields(this) };
   }
   decorateForwardResult(result) {
-    return { ...result, ...this.getCoordinatorMessageFields() };
+    return { ...result, ...getCoordinatorMessageFields(this) };
   }
   decorateSyncRequest(request) {
-    return { ...request, ...this.getCoordinatorMessageFields() };
+    return { ...request, ...getCoordinatorMessageFields(this) };
   }
   decorateSyncBatch(batch) {
-    return { ...batch, ...this.getCoordinatorMessageFields() };
+    return { ...batch, ...getCoordinatorMessageFields(this) };
   }
   decorateSyncComplete(complete) {
-    return { ...complete, ...this.getCoordinatorMessageFields() };
+    return { ...complete, ...getCoordinatorMessageFields(this) };
   }
   decorateSyncAck(ack) {
-    return { ...ack, ...this.getCoordinatorMessageFields() };
+    return { ...ack, ...getCoordinatorMessageFields(this) };
   }
   resolveWriteConcern(wc) {
     if (wc) return wc;
@@ -3341,431 +3117,9 @@ var ReplicationEngine = class extends EventEmitter {
     return void 0;
   }
   getCurrentPrimaryPeerId() {
-    return this.getForwardingPrimaryPeerId();
-  }
-  async canAcceptLocalWrite() {
-    if (!this.isCoordinatorMode()) {
-      return this.config.topology.canWrite();
-    }
-    const state = await this.refreshCoordinatorState();
-    if (!state) {
-      throw new CoordinatorError("Cannot prove write authority without replication-group state");
-    }
-    if (!this.hasCurrentPrimaryAuthorityFor(state)) {
-      return false;
-    }
-    this.assertLocalCompatibility(state);
-    if (state.drainingNodeIds.includes(this.nodeId)) {
-      throw new NodeDrainingError("Node is draining and cannot accept writes", this.errorDetails(state));
-    }
-    if (state.repairingNodeIds.includes(this.nodeId) || state.faultedNodeIds.includes(this.nodeId)) {
-      throw new AuthorityError(
-        "Node is not eligible to accept writes while repair or fault state is active",
-        "AUTHORITY_LOST",
-        this.errorDetails(state)
-      );
-    }
-    return true;
-  }
-  throwNotCurrentPrimary() {
-    if (this.isCoordinatorMode()) {
-      throw new StalePrimaryError("This node is not the current primary", this.errorDetails(this.coordinatorState));
-    }
-    throw new TopologyError("This node cannot accept writes");
-  }
-  async assertReadConcern(level) {
-    if (!this.isCoordinatorMode()) return;
-    const readConcern = level ?? "majority";
-    if (readConcern === "local") return;
-    const state = await this.refreshCoordinatorState();
-    if (!state) {
-      throw new CoordinatorError("Cannot satisfy read concern without replication-group state");
-    }
-    if (readConcern === "linearizable") {
-      await this.verifyPrimaryAuthority();
-      return;
-    }
-    if (readConcern === "majority") {
-      if (!state.inSyncNodeIds.includes(this.nodeId)) {
-        throw new NodeNotInSyncError("Node is not in the in-sync set for majority reads", this.errorDetails(state));
-      }
-      if (state.drainingNodeIds.includes(this.nodeId) || state.repairingNodeIds.includes(this.nodeId)) {
-        throw new ReadConcernError(
-          "Node cannot serve majority reads while draining or repairing",
-          this.errorDetails(state)
-        );
-      }
-      return;
-    }
-    throw new ReadConcernError(`Unsupported read concern '${readConcern}'`, this.errorDetails(state));
-  }
-  async refreshCoordinatorState() {
-    const config = this.config.coordinator;
-    if (!config) return null;
-    try {
-      const state = await config.coordinator.getReplicationGroupState(config.clusterId, config.groupId);
-      this.coordinatorState = state;
-      this.coordinatorAuthority = state ? this.hasCurrentPrimaryAuthorityFor(state) : false;
-      return state;
-    } catch {
-      this.coordinatorAuthority = false;
-      throw new CoordinatorError(
-        "Coordinator is unavailable while refreshing replication-group authority",
-        this.errorDetails(this.coordinatorState)
-      );
-    }
-  }
-  hasCurrentPrimaryAuthorityFor(state) {
-    return state.currentPrimary?.nodeId === this.nodeId;
-  }
-  getCoordinatorMessageFields() {
-    const config = this.config.coordinator;
-    if (!config) return {};
-    return {
-      groupId: config.groupId,
-      primaryTerm: this.coordinatorState?.primaryTerm ?? this.config.transportConfig?.primaryTerm
-    };
-  }
-  getForwardingPrimaryPeerId() {
-    if (this.isCoordinatorMode()) {
-      const primaryId = this.coordinatorState?.currentPrimary?.nodeId;
-      if (primaryId && this.config.transport.peers().has(primaryId)) {
-        return primaryId;
-      }
-      return null;
-    }
-    for (const [peerId, info] of this.config.transport.peers()) {
-      if (info.role === "primary") {
-        return peerId;
-      }
-    }
-    return null;
-  }
-  async updateCoordinatorProgressAfterWrite(seq, state) {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const ackedNodeIds = this.peerTracker.ackedConfiguredNodeIds(seq, this.nodeId, state.votingDataBearingNodeIds);
-    const retainedInSync = state.inSyncNodeIds.filter((nodeId) => ackedNodeIds.includes(nodeId));
-    let nextState = state;
-    if (!arraysEqual(retainedInSync, state.inSyncNodeIds) || state.durabilityPointSeq < seq) {
-      const updated = await config.coordinator.updateInSyncSet({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        inSyncNodeIds: retainedInSync,
-        durabilityPointSeq: seq
-      });
-      if (!updated) {
-        throw new CoordinatorError("Failed to update in-sync set before acknowledging majority write");
-      }
-      nextState = updated;
-    }
-    for (const nodeId of ackedNodeIds) {
-      if (nextState.inSyncNodeIds.includes(nodeId)) continue;
-      if (nodeId === this.nodeId) continue;
-      const admitted = await config.coordinator.admitNodeToInSyncSet({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        nodeId,
-        sourceNodeId: this.nodeId,
-        appliedSeq: seq
-      });
-      if (!admitted) {
-        throw new CoordinatorError("Failed to admit ACKing node to in-sync set before acknowledging majority write");
-      }
-      nextState = admitted;
-    }
-    this.coordinatorState = nextState;
-  }
-  startCoordinatorLeaseRenewal() {
-    const config = this.config.coordinator;
-    const leaseId = this.nodeSessionLeaseId;
-    if (!config || !leaseId) return;
-    const ttlMs = config.sessionTtlMs ?? DEFAULT_COORDINATOR_SESSION_TTL_MS;
-    const timer = setInterval(
-      () => {
-        config.coordinator.renewLease(leaseId, ttlMs).then((renewed) => {
-          if (!renewed) {
-            this.coordinatorAuthority = false;
-          }
-        }).catch((err) => {
-          this.coordinatorAuthority = false;
-          const wrappedErr = err instanceof Error ? err : new Error(String(err));
-          this.emitError({ error: wrappedErr, operation: "coordinator-session-renew", recoverable: false });
-        });
-      },
-      Math.max(1e3, Math.floor(ttlMs / 3))
-    );
-    this.unrefTimer(timer);
-    this.coordinatorLeaseTimer = timer;
-  }
-  startControllerLoop() {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const controllerConfig = typeof config.controller === "object" ? config.controller : {};
-    const enabled = typeof config.controller === "boolean" ? config.controller : controllerConfig.enabled ?? true;
-    if (!enabled) {
-      this.controllerState = "disabled";
-      return;
-    }
-    this.controllerState = "standby";
-    const ttlMs = controllerConfig.leaseTtlMs ?? DEFAULT_CONTROLLER_LEASE_TTL_MS;
-    const holderId = controllerConfig.holderId ?? this.nodeId;
-    const tickMs = controllerConfig.tickIntervalMs ?? DEFAULT_CONTROLLER_TICK_INTERVAL_MS;
-    const timer = setInterval(() => {
-      this.controllerTick(holderId, ttlMs).catch((err) => {
-        const wrappedErr = err instanceof Error ? err : new Error(String(err));
-        this.controllerState = "lost";
-        this.emitError({ error: wrappedErr, operation: "coordinator-controller", recoverable: true });
-      });
-    }, tickMs);
-    this.unrefTimer(timer);
-    this.controllerTimer = timer;
-  }
-  async controllerTick(holderId, ttlMs) {
-    const config = this.config.coordinator;
-    if (!config) return;
-    if (this.controllerLeaseId) {
-      const renewed = await config.coordinator.renewLease(this.controllerLeaseId, ttlMs);
-      if (!renewed) {
-        this.controllerLeaseId = null;
-        this.controllerState = "lost";
-        return;
-      }
-      this.controllerState = "active";
-      await this.runControllerPromotionCheck();
-      return;
-    }
-    const acquired = await config.coordinator.tryAcquireControllerLease({
-      clusterId: config.clusterId,
-      holderId,
-      ttlMs
-    });
-    if (acquired.acquired) {
-      this.controllerLeaseId = acquired.lease.id;
-      this.controllerState = "active";
-      await this.runControllerPromotionCheck();
-    } else {
-      this.controllerState = "standby";
-    }
-  }
-  async runControllerPromotionCheck() {
-    const config = this.config.coordinator;
-    if (!config) return;
-    const state = await this.refreshCoordinatorState();
-    if (!state) return;
-    const primaryNodeId = state.currentPrimary?.nodeId;
-    const primaryLive = primaryNodeId ? await config.coordinator.getLiveNodeSession(config.clusterId, primaryNodeId) : null;
-    const primaryCanKeepDuty = primaryNodeId && primaryLive && compatibilityAllowsPromotion(state.compatibility, primaryLive.compatibility) && !state.drainingNodeIds.includes(primaryNodeId) && !state.repairingNodeIds.includes(primaryNodeId) && !state.faultedNodeIds.includes(primaryNodeId);
-    if (primaryCanKeepDuty) {
-      return;
-    }
-    try {
-      const promoted = await config.coordinator.promoteEligibleReplica({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        excludeNodeIds: primaryNodeId ? [primaryNodeId] : []
-      });
-      this.coordinatorState = promoted;
-      this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(promoted);
-    } catch (err) {
-      const wrappedErr = err instanceof Error ? err : new Error(String(err));
-      this.emitError({ error: wrappedErr, operation: "coordinator-promotion", recoverable: true });
-    }
-  }
-  handleCoordinatorStateUpdate(next) {
-    const previous = this.coordinatorState;
-    const wasPrimary = previous ? this.hasCurrentPrimaryAuthorityFor(previous) : this.coordinatorAuthority;
-    this.coordinatorState = next;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(next);
-    if (wasPrimary && !this.coordinatorAuthority && next.primaryTerm > (previous?.primaryTerm ?? 0n)) {
-      this.handleFormerPrimaryDemotion(next).catch((err) => {
-        const wrappedErr = err instanceof Error ? err : new Error(String(err));
-        this.emitError({ error: wrappedErr, operation: "coordinator-former-primary-demotion", recoverable: false });
-      });
-      return;
-    }
-    this.startCoordinatorRejoinSyncIfReady(next);
-  }
-  startCoordinatorRejoinSyncIfReady(state) {
-    if (!this.running) return;
-    if (this.coordinatorRejoinSyncStarting) return;
-    if (!this.requiresCoordinatorRejoinSync(state)) return;
-    if (this.syncState.phase !== "pending") return;
-    const sourceNodeId = state.currentPrimary?.nodeId;
-    if (!sourceNodeId || !this.config.transport.peers().has(sourceNodeId)) return;
-    this.coordinatorRejoinSyncStarting = true;
-    this.syncJoiner.initiateSync().catch((err) => {
-      const wrappedErr = err instanceof Error ? err : new Error(String(err));
-      this.emitError({ error: wrappedErr, operation: "coordinator-rejoin-sync", recoverable: true });
-    }).finally(() => {
-      this.coordinatorRejoinSyncStarting = false;
-    });
-  }
-  async handleFormerPrimaryDemotion(state) {
-    const repairingState = await this.markLocalNodeRepairing(state);
-    const evaluatedState = await this.evaluateFormerPrimaryHistory(repairingState);
-    if (!this.requiresCoordinatorRejoinSync(evaluatedState)) return;
-    if (!this.running || this.syncState.phase === "syncing" || this.syncState.phase === "catching-up") return;
-    this.syncState = {
-      phase: "pending",
-      sourcePeerId: null,
-      snapshotSeq: null,
-      completedTables: [],
-      totalTables: 0,
-      startedAt: null,
-      error: null
-    };
-    await this.log.setSyncMeta("pending");
-    await this.syncJoiner.initiateSync();
-  }
-  async markLocalNodeRepairing(state) {
-    const config = this.config.coordinator;
-    if (!config || state.repairingNodeIds.includes(this.nodeId) || state.faultedNodeIds.includes(this.nodeId)) {
-      return state;
-    }
-    const updated = await config.coordinator.updateNodeMaintenance({
-      clusterId: config.clusterId,
-      groupId: config.groupId,
-      nodeId: this.nodeId,
-      repairing: true
-    });
-    if (!updated) {
-      throw new CoordinatorError("Failed to mark former primary for repair");
-    }
-    this.coordinatorState = updated;
-    this.coordinatorAuthority = this.hasCurrentPrimaryAuthorityFor(updated);
-    return updated;
-  }
-  requiresCoordinatorRejoin(state) {
-    if (state.currentPrimary?.nodeId === this.nodeId) return false;
-    return state.repairingNodeIds.includes(this.nodeId) || state.faultedNodeIds.includes(this.nodeId);
-  }
-  assertLocalCompatibility(state) {
-    if (compatibilityAllowsPromotion(state.compatibility, this.config.coordinator?.compatibility)) return;
-    throw new ProtocolVersionMismatchError("Node compatibility metadata is incompatible with the replication group", {
-      ...this.errorDetails(state),
-      groupCompatibility: state.compatibility,
-      localCompatibility: this.config.coordinator?.compatibility
-    });
-  }
-  async evaluateFormerPrimaryHistory(state) {
-    const config = this.config.coordinator;
-    const currentPrimary = state.currentPrimary;
-    if (!config || !currentPrimary || state.faultedNodeIds.includes(this.nodeId)) return state;
-    const localSeq = await this.log.getLocalSeq();
-    const currentPrimaryAckedSeq = await this.log.getPeerAckedSeq(currentPrimary.nodeId);
-    if (localSeq <= currentPrimaryAckedSeq) {
-      return state;
-    }
-    const inSyncNodeIds = state.inSyncNodeIds.filter((nodeId) => nodeId !== this.nodeId);
-    let nextState = state;
-    if (inSyncNodeIds.length !== state.inSyncNodeIds.length) {
-      const updated = await config.coordinator.updateInSyncSet({
-        clusterId: config.clusterId,
-        groupId: config.groupId,
-        inSyncNodeIds
-      });
-      if (!updated) {
-        throw new CoordinatorError("Failed to remove divergent former primary from in-sync set");
-      }
-      nextState = updated;
-    }
-    const faulted = await config.coordinator.updateNodeMaintenance({
-      clusterId: config.clusterId,
-      groupId: config.groupId,
-      nodeId: this.nodeId,
-      repairing: false,
-      faulted: true
-    });
-    nextState = faulted ?? nextState;
-    this.coordinatorState = nextState;
-    this.coordinatorAuthority = false;
-    this.emitError({
-      error: new AuthorityError(
-        "Former primary returned with local-only writes and was quarantined",
-        "AUTHORITY_LOST",
-        {
-          ...this.errorDetails(nextState),
-          localSeq: localSeq.toString(),
-          currentPrimaryAckedSeq: currentPrimaryAckedSeq.toString()
-        }
-      ),
-      operation: "coordinator-former-primary-divergence",
-      recoverable: false
-    });
-    return nextState;
-  }
-  stopCoordinatorTimers() {
-    if (this.coordinatorLeaseTimer) {
-      clearInterval(this.coordinatorLeaseTimer);
-      this.coordinatorLeaseTimer = null;
-    }
-    if (this.controllerTimer) {
-      clearInterval(this.controllerTimer);
-      this.controllerTimer = null;
-    }
-  }
-  async stopCoordinatorMode() {
-    const config = this.config.coordinator;
-    if (!config) return;
-    if (this.coordinatorWatchDisposer) {
-      await this.coordinatorWatchDisposer();
-      this.coordinatorWatchDisposer = null;
-    }
-    if (this.controllerLeaseId) {
-      const leaseId = this.controllerLeaseId;
-      this.controllerLeaseId = null;
-      await config.coordinator.releaseLease(leaseId).catch((err) => {
-        const wrappedErr = err instanceof Error ? err : new Error(String(err));
-        this.emitError({ error: wrappedErr, operation: "coordinator-controller-release", recoverable: true });
-      });
-    }
-    await config.coordinator.deregisterNodeSession(config.clusterId, this.nodeId).catch((err) => {
-      const wrappedErr = err instanceof Error ? err : new Error(String(err));
-      this.emitError({ error: wrappedErr, operation: "coordinator-session-deregister", recoverable: true });
-    });
-  }
-  localCoordinatorPrimary() {
-    const endpoint = this.config.coordinator?.endpoint;
-    return endpoint ? { nodeId: this.nodeId, endpoint } : { nodeId: this.nodeId };
-  }
-  unrefTimer(timer) {
-    const unref = timer.unref;
-    unref?.call(timer);
-  }
-  getCoordinatorRuntimeStatus() {
-    const config = this.config.coordinator;
-    const state = this.coordinatorState;
-    if (!config || !state) return void 0;
-    return {
-      clusterId: config.clusterId,
-      groupId: config.groupId,
-      currentPrimary: state.currentPrimary ? { ...state.currentPrimary } : null,
-      primaryTerm: state.primaryTerm,
-      inSyncNodeIds: [...state.inSyncNodeIds],
-      drainingNodeIds: [...state.drainingNodeIds],
-      repairingNodeIds: [...state.repairingNodeIds],
-      faultedNodeIds: [...state.faultedNodeIds],
-      votingDataBearingNodeIds: [...state.votingDataBearingNodeIds],
-      authority: this.coordinatorAuthority,
-      controllerState: this.controllerState
-    };
-  }
-  errorDetails(state) {
-    return {
-      currentPrimary: state?.currentPrimary ?? null,
-      primaryTerm: state?.primaryTerm.toString(),
-      replicationGroupId: this.config.coordinator?.groupId
-    };
+    return getForwardingPrimaryPeerId(this);
   }
 };
-function arraysEqual(left, right) {
-  if (left.length !== right.length) return false;
-  for (let i = 0; i < left.length; i++) {
-    if (left[i] !== right[i]) return false;
-  }
-  return true;
-}
 
 // src/replication/topology/primary-replica.ts
 var PrimaryReplicaTopology = class {
@@ -3787,4 +3141,4 @@ var PrimaryReplicaTopology = class {
   }
 };
 
-export { FieldMergeResolver, HLC, LWWResolver, PeerTracker, PrimaryReplicaTopology, PrimaryWinsResolver, ReplicationEngine, ReplicationLog, generateNodeId, validateNodeId };
+export { FieldMergeResolver, PeerTracker, PrimaryReplicaTopology, PrimaryWinsResolver, ReplicationEngine, ReplicationLog, generateNodeId, validateNodeId };