@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/replication/index.mjs

@@ -0,0 +1,3784 @@
+import { Transaction } from '../chunk-3MCMONVP.mjs';
+import { decodeTaggedValues } from '../chunk-GS7T5YMI.mjs';
+import { compatibilityAllowsPromotion } from '../chunk-ER7ODTDA.mjs';
+import { ReplicationError, WriteConcernError, AuthorityError, SyncError, TopologyError, CoordinatorError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError, BatchValidationError } from '../chunk-UVMVN3OT.mjs';
+export { AuthorityError, BatchValidationError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, ReplicationError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-UVMVN3OT.mjs';
+import '../chunk-O7BHI3CF.mjs';
+import { randomBytes, randomUUID, createHash } from 'crypto';
+import { EventEmitter } from 'events';
+
+// 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/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
+var FieldMergeResolver = class {
+  getColumnVersions;
+  lww = new LWWResolver();
+  constructor(getColumnVersions) {
+    this.getColumnVersions = getColumnVersions;
+  }
+  async resolve(ctx) {
+    const columnVersions = await this.getColumnVersions(ctx.table, ctx.rowId);
+    if (columnVersions.size === 0) {
+      return this.lww.resolve(ctx);
+    }
+    const localData = ctx.localChange?.newData ?? ctx.localChange?.oldData ?? {};
+    const remoteData = ctx.remoteChange.newData ?? {};
+    const oldData = ctx.remoteChange.oldData ?? {};
+    const localChanged = /* @__PURE__ */ new Set();
+    const remoteChanged = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(localData)) {
+      if (JSON.stringify(localData[key]) !== JSON.stringify(oldData[key])) {
+        localChanged.add(key);
+      }
+    }
+    for (const key of Object.keys(remoteData)) {
+      if (JSON.stringify(remoteData[key]) !== JSON.stringify(oldData[key])) {
+        remoteChanged.add(key);
+      }
+    }
+    const overlapping = /* @__PURE__ */ new Set();
+    for (const key of remoteChanged) {
+      if (localChanged.has(key)) {
+        overlapping.add(key);
+      }
+    }
+    if (overlapping.size === 0 && (localChanged.size > 0 || remoteChanged.size > 0)) {
+      const merged2 = { ...localData };
+      for (const key of remoteChanged) {
+        merged2[key] = remoteData[key];
+      }
+      return { action: "merge", mergedData: merged2 };
+    }
+    const merged = { ...localData };
+    let anyRemoteWins = false;
+    for (const key of overlapping) {
+      const cv = columnVersions.get(key);
+      if (!cv) {
+        const rowLww = this.lww.resolve(ctx);
+        if (rowLww.action === "accept_remote") {
+          merged[key] = remoteData[key];
+          anyRemoteWins = true;
+        }
+        continue;
+      }
+      const cmp = HLC.compare(ctx.remoteHlc, cv.hlc);
+      if (cmp > 0) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
+      } else if (cmp === 0 && ctx.remoteChange.nodeId > cv.nodeId) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
+      }
+    }
+    for (const key of remoteChanged) {
+      if (!overlapping.has(key)) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
+      }
+    }
+    if (anyRemoteWins) {
+      return { action: "merge", mergedData: merged };
+    }
+    return { action: "keep_local" };
+  }
+};
+
+// src/replication/conflict/primary-wins.ts
+var PrimaryWinsResolver = class {
+  primaryNodeId;
+  lww = new LWWResolver();
+  constructor(primaryNodeId) {
+    this.primaryNodeId = primaryNodeId;
+  }
+  resolve(ctx) {
+    if (ctx.remoteChange.nodeId === this.primaryNodeId) {
+      return { action: "accept_remote" };
+    }
+    if (ctx.localChange?.nodeId === this.primaryNodeId) {
+      return { action: "keep_local" };
+    }
+    return this.lww.resolve(ctx);
+  }
+};
+
+// 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/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 _sirannon_column_versions 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 _sirannon_column_versions (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 _sirannon_applied_changes 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 _sirannon_applied_changes (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 _sirannon_column_versions 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 _sirannon_column_versions WHERE table_name = ? AND row_id = ?");
+      await delStmt.run(change.table, change.rowId);
+      return;
+    }
+    if (!data) return;
+    const upsertStmt = await tx.prepare(
+      `INSERT INTO _sirannon_column_versions (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) {
+    this.conn = conn;
+    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 _sirannon_peer_state (
+	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 _sirannon_applied_changes (
+	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 _sirannon_column_versions (
+	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 _sirannon_sync_state (
+	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
+)`);
+  }
+  async dumpSchema(conn, excludePrefix = "_sirannon_") {
+    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;
+  }
+  async getTablesInFkOrder(conn) {
+    const stmt = await conn.prepare(
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE '_sirannon_%' 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;
+  }
+  async wipeTables(conn, tables, tracker) {
+    for (const table of tables) {
+      if (!IDENTIFIER_RE2.test(table)) {
+        throw new ReplicationError(`Invalid table name: ${table}`);
+      }
+    }
+    await conn.exec("PRAGMA foreign_keys = OFF");
+    try {
+      await conn.transaction(async (tx) => {
+        for (const table of tables) {
+          await tracker.unwatch(tx, table);
+        }
+        const reversed = [...tables].reverse();
+        for (const table of reversed) {
+          await tx.exec(`DELETE FROM "${table}"`);
+        }
+        await tx.exec(`DELETE FROM _sirannon_sync_state WHERE table_name != '__sync_meta__'`);
+      });
+    } finally {
+      await conn.exec("PRAGMA foreign_keys = ON");
+    }
+  }
+};
+
+// src/replication/log/state.ts
+var StateOps = class {
+  constructor(conn) {
+    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 _sirannon_column_versions WHERE hlc != ''`
+    );
+    const versionsRow = await versionsStmt.get();
+    best = mergeCandidate(best, versionsRow?.max_hlc ?? null);
+    return best;
+  }
+  async getLastAppliedSeq(fromNodeId) {
+    const stmt = await this.conn.prepare(
+      "SELECT MAX(source_seq) as max_seq FROM _sirannon_applied_changes 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 _sirannon_peer_state (peer_node_id, last_acked_seq, updated_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(peer_node_id)
+       DO UPDATE SET
+         last_acked_seq = max(_sirannon_peer_state.last_acked_seq, excluded.last_acked_seq),
+         updated_at = CASE
+           WHEN excluded.last_acked_seq >= _sirannon_peer_state.last_acked_seq THEN excluded.updated_at
+           ELSE _sirannon_peer_state.updated_at
+         END`
+    );
+    await stmt.run(fromNodeId, seq.toString(), Date.now() / 1e3);
+  }
+  async getPeerAckedSeq(peerNodeId) {
+    const stmt = await this.conn.prepare("SELECT last_acked_seq FROM _sirannon_peer_state 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);
+  }
+  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);
+  }
+  async getMinAckedSeq() {
+    const stmt = await this.conn.prepare(
+      "SELECT MIN(last_acked_seq) as min_seq, COUNT(*) as cnt FROM _sirannon_peer_state"
+    );
+    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;
+    }
+    for (const syncSeq of this.activeSyncSnapshotSeqs) {
+      if (result === null || syncSeq < result) {
+        result = syncSeq;
+      }
+    }
+    return result;
+  }
+  registerActiveSyncSeq(seq) {
+    this.activeSyncSnapshotSeqs.add(seq);
+  }
+  unregisterActiveSyncSeq(seq) {
+    this.activeSyncSnapshotSeqs.delete(seq);
+  }
+  async setSyncTableStatus(table, status, rowCount, pkHash) {
+    const stmt = await this.conn.prepare(
+      `INSERT INTO _sirannon_sync_state (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 _sirannon_sync_state (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
+    );
+  }
+  async getSyncState() {
+    const metaStmt = await this.conn.prepare(
+      `SELECT status, snapshot_seq, source_peer_id FROM _sirannon_sync_state WHERE table_name = '__sync_meta__'`
+    );
+    const meta = await metaStmt.get();
+    if (!meta) {
+      return { phase: "ready", completedTables: [], snapshotSeq: null, sourcePeerId: null };
+    }
+    const completedStmt = await this.conn.prepare(
+      `SELECT table_name FROM _sirannon_sync_state 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
+    };
+  }
+  async isSyncCompleted() {
+    const stmt = await this.conn.prepare(`SELECT status FROM _sirannon_sync_state WHERE table_name = '__sync_meta__'`);
+    const row = await stmt.get();
+    return row?.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;
+  if (current === null) return candidate;
+  return HLC.compare(candidate, current) > 0 ? candidate : current;
+}
+
+// src/replication/log/log.ts
+var ReplicationLog = class {
+  constructor(conn, localNodeId, hlc, changesTable = "_sirannon_changes", tracker) {
+    this.changesTable = changesTable;
+    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.batchApplier = new BatchApplier(
+      conn,
+      localNodeId,
+      hlc,
+      this.pkResolver,
+      (fromNodeId) => this.state.getLastAppliedSeq(fromNodeId),
+      tracker
+    );
+    this.dump = new DumpOps(conn, localNodeId, hlc, this.pkResolver);
+  }
+  pkResolver;
+  state;
+  schema;
+  batchReader;
+  batchApplier;
+  dump;
+  ensureReplicationTables() {
+    return this.schema.ensureReplicationTables();
+  }
+  readBatch(afterSeq, batchSize) {
+    return this.batchReader.readBatch(afterSeq, batchSize);
+  }
+  stampChanges(tx, afterSeq, txId) {
+    return this.batchReader.stampChanges(tx, afterSeq, txId);
+  }
+  updateColumnVersions(tx, afterSeq) {
+    return this.batchReader.updateColumnVersions(tx, afterSeq);
+  }
+  applyBatch(batch, resolver) {
+    return this.batchApplier.applyBatch(batch, resolver);
+  }
+  getLastAppliedSeq(fromNodeId) {
+    return this.state.getLastAppliedSeq(fromNodeId);
+  }
+  setLastAppliedSeq(fromNodeId, seq) {
+    return this.state.setLastAppliedSeq(fromNodeId, seq);
+  }
+  getPeerAckedSeq(peerNodeId) {
+    return this.state.getPeerAckedSeq(peerNodeId);
+  }
+  getLocalSeq() {
+    return this.state.getLocalSeq(this.changesTable);
+  }
+  recoverMaxObservedHlc() {
+    return this.state.recoverMaxObservedHlc(this.changesTable);
+  }
+  getMinAckedSeq() {
+    return this.state.getMinAckedSeq();
+  }
+  registerActiveSyncSeq(seq) {
+    this.state.registerActiveSyncSeq(seq);
+  }
+  unregisterActiveSyncSeq(seq) {
+    this.state.unregisterActiveSyncSeq(seq);
+  }
+  dumpTable(table, batchSize) {
+    return this.dump.dumpTable(table, batchSize);
+  }
+  dumpTableOnConnection(conn, table, batchSize) {
+    return this.dump.dumpTableOnConnection(conn, table, batchSize);
+  }
+  dumpSchema(conn, excludePrefix) {
+    return this.schema.dumpSchema(conn, excludePrefix);
+  }
+  getTablesInFkOrder(conn) {
+    return this.schema.getTablesInFkOrder(conn);
+  }
+  wipeTables(conn, tables, tracker) {
+    return this.schema.wipeTables(conn, tables, tracker);
+  }
+  setSyncTableStatus(table, status, rowCount, pkHash) {
+    return this.state.setSyncTableStatus(table, status, rowCount, pkHash);
+  }
+  setSyncMeta(phase, snapshotSeq, sourcePeerId, requestId) {
+    return this.state.setSyncMeta(phase, snapshotSeq, sourcePeerId, requestId);
+  }
+  getSyncState() {
+    return this.state.getSyncState();
+  }
+  isSyncCompleted() {
+    return this.state.isSyncCompleted();
+  }
+  generateManifest(conn, table) {
+    return this.dump.generateManifest(conn, table);
+  }
+  verifyManifest(manifest) {
+    return this.dump.verifyManifest(manifest);
+  }
+};
+var NODE_ID_RE = /^[0-9a-f]{32}$/;
+function generateNodeId() {
+  return randomBytes(16).toString("hex");
+}
+function validateNodeId(id) {
+  if (!NODE_ID_RE.test(id)) {
+    throw new ReplicationError(`Invalid node ID '${id}': must be 32 lowercase hex characters`);
+  }
+}
+
+// src/replication/peer-tracker.ts
+var PeerTracker = class {
+  peers = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  addPeer(nodeId) {
+    if (this.peers.has(nodeId)) {
+      const existing = this.peers.get(nodeId);
+      if (existing) {
+        existing.connected = true;
+      }
+      return;
+    }
+    this.peers.set(nodeId, {
+      nodeId,
+      lastAckedSeq: 0n,
+      lastSentSeq: 0n,
+      lastReceivedHlc: "",
+      connected: true,
+      pendingBatches: 0,
+      inFlightBatches: []
+    });
+  }
+  removePeer(nodeId) {
+    const peer = this.peers.get(nodeId);
+    if (peer) {
+      peer.connected = false;
+    }
+    this.checkWaiters();
+  }
+  onAckReceived(nodeId, ackedSeq) {
+    const peer = this.peers.get(nodeId);
+    if (peer && ackedSeq > peer.lastAckedSeq) {
+      peer.lastAckedSeq = ackedSeq;
+      const ackedCount = peer.inFlightBatches.filter((b) => b.toSeq <= ackedSeq).length;
+      peer.inFlightBatches = peer.inFlightBatches.filter((b) => b.toSeq > ackedSeq);
+      peer.pendingBatches = Math.max(0, peer.pendingBatches - Math.max(1, ackedCount));
+    }
+    this.checkWaiters();
+  }
+  recordInFlightBatch(nodeId, batch) {
+    const peer = this.peers.get(nodeId);
+    if (peer) {
+      peer.inFlightBatches.push(batch);
+    }
+  }
+  expireTimedOutBatches(nodeId, nowMs, timeoutMs) {
+    const peer = this.peers.get(nodeId);
+    if (!peer || peer.inFlightBatches.length === 0) return false;
+    const timedOut = peer.inFlightBatches.filter((b) => nowMs - b.sentAt >= timeoutMs);
+    if (timedOut.length === 0) return false;
+    let earliestFromSeq = timedOut[0].fromSeq;
+    for (let i = 1; i < timedOut.length; i++) {
+      if (timedOut[i].fromSeq < earliestFromSeq) {
+        earliestFromSeq = timedOut[i].fromSeq;
+      }
+    }
+    peer.inFlightBatches = peer.inFlightBatches.filter((b) => nowMs - b.sentAt < timeoutMs);
+    peer.pendingBatches = Math.max(0, peer.pendingBatches - timedOut.length);
+    const resetTarget = earliestFromSeq > 0n ? earliestFromSeq - 1n : 0n;
+    if (peer.lastSentSeq > resetTarget) {
+      peer.lastSentSeq = resetTarget;
+    }
+    return true;
+  }
+  getPeerState(nodeId) {
+    return this.peers.get(nodeId);
+  }
+  connectedPeerCount() {
+    let count = 0;
+    for (const peer of this.peers.values()) {
+      if (peer.connected) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  waitForMajority(seq, timeoutMs) {
+    const connected = this.connectedPeerCount();
+    const needed = Math.floor(connected / 2) + 1;
+    if (this.countAcked(seq) >= needed) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new WriteConcernError(`Timed out waiting for majority ACK of seq ${seq}`));
+      }, timeoutMs);
+      timer.unref?.();
+      const waiter = { seq, kind: "majority", resolve, reject, timer };
+      this.waiters.add(waiter);
+    });
+  }
+  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/replication-transaction.ts
+var ReplicationTransaction = class extends Transaction {
+  constructor(txConn, hooks) {
+    super(txConn);
+    this.hooks = hooks;
+  }
+  async execute(sql, params) {
+    const isDdl = DDL_PREFIX_RE.test(sql);
+    if (isDdl && sql.includes(";")) {
+      throw new ReplicationError("DDL statements containing semicolons are not allowed for replication safety");
+    }
+    const result = await super.execute(sql, params);
+    if (isDdl) {
+      this.hooks.sawDdl = true;
+      await this.hooks.onDdl(sql);
+    }
+    return result;
+  }
+  async executeBatch(sql, paramsBatch) {
+    if (DDL_PREFIX_RE.test(sql)) {
+      throw new ReplicationError("DDL statements are not allowed via executeBatch inside a replication transaction");
+    }
+    return super.executeBatch(sql, paramsBatch);
+  }
+};
+
+// src/replication/engine/local-executor.ts
+var LocalExecutor = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  /**
+   * Serialises every `executeTransactionLocally` call against itself.
+   *
+   * Reason: SQLite only allows one active transaction per connection; the
+   * writer pool exposes a single writer connection (see `ConnectionPool`).
+   * Two parallel `engine.transaction(fn)` callers therefore both reach
+   * `await conn.exec('BEGIN')` on the same connection, and the second
+   * `BEGIN` errors with "cannot start a transaction within a transaction".
+   * Chaining onto this promise turns the second caller into a strict
+   * follow-on without changing the public API. A rejection is swallowed at
+   * the chain level so a failed transaction never poisons the queue; the
+   * original error still surfaces to the caller that initiated it.
+   */
+  transactionQueue = Promise.resolve();
+  async executeLocally(sql, params, options) {
+    const engine = this.engine;
+    const isDdl = DDL_PREFIX_RE.test(sql);
+    if (isDdl && sql.includes(";")) {
+      throw new ReplicationError("DDL statements containing semicolons are not allowed for replication safety");
+    }
+    const txId = randomUUID();
+    const droppedTable = isDdl ? extractDroppedTable(sql) : null;
+    const result = await engine.writerConn.transaction(async (tx) => {
+      const seqBefore = await engine.log.getLocalSeq();
+      const bindValues = params ? Array.isArray(params) ? params : [params] : [];
+      const stmt = await tx.prepare(sql);
+      const r = await stmt.run(...bindValues);
+      if (isDdl) {
+        const ddlStmt = await tx.prepare(
+          `INSERT INTO "_sirannon_changes" (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);
+      } else {
+        await engine.log.stampChanges(tx, seqBefore, txId);
+        await engine.log.updateColumnVersions(tx, seqBefore);
+      }
+      return { changes: r.changes, lastInsertRowId: r.lastInsertRowId };
+    });
+    const newSeq = await engine.log.getLocalSeq();
+    if (newSeq > engine.lastLocalSeq) {
+      engine.lastLocalSeq = newSeq;
+    }
+    if (isDdl) {
+      if (droppedTable !== null && engine.tracker) {
+        await engine.tracker.pruneDroppedTables(engine.writerConn, [droppedTable]);
+      }
+      await engine.refreshTriggersAfterDdl();
+    }
+    const writeConcern = engine.resolveWriteConcern(options?.writeConcern);
+    if (writeConcern) {
+      await engine.waitForWriteConcern(newSeq, writeConcern);
+    }
+    return result;
+  }
+  async executeForwardedLocally(statements) {
+    const engine = this.engine;
+    const requestId = randomUUID();
+    const results = [];
+    const txId = randomUUID();
+    const hook = engine.config.onBeforeForwardedQuery;
+    for (const { sql } of statements) {
+      if (!SAFE_SQL_PREFIX_RE.test(sql)) {
+        throw new ReplicationError("Forwarded statement rejected: only DML and safe DDL are allowed");
+      }
+    }
+    if (hook) {
+      for (const { sql, params } of statements) {
+        hook(sql, params);
+      }
+    }
+    let sawDdl = false;
+    const droppedTables = [];
+    await engine.writerConn.transaction(async (tx) => {
+      const seqBefore = await engine.log.getLocalSeq();
+      for (const { sql, params } of statements) {
+        const isDdl = DDL_PREFIX_RE.test(sql);
+        if (isDdl && sql.includes(";")) {
+          throw new ReplicationError("DDL statements containing semicolons are not allowed for replication safety");
+        }
+        const bindValues = params ? Array.isArray(params) ? params : [params] : [];
+        const stmt = await tx.prepare(sql);
+        const r = await stmt.run(...bindValues);
+        results.push({
+          changes: r.changes,
+          lastInsertRowId: typeof r.lastInsertRowId === "bigint" ? r.lastInsertRowId.toString() : r.lastInsertRowId
+        });
+        if (isDdl) {
+          sawDdl = true;
+          const droppedTable = extractDroppedTable(sql);
+          if (droppedTable !== null) {
+            droppedTables.push(droppedTable);
+          }
+          const ddlStmt = await tx.prepare(
+            `INSERT INTO "_sirannon_changes" (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);
+          if (engine.tracker) {
+            await engine.tracker.refreshAllTriggersUsingConnection(tx);
+          }
+        }
+      }
+      await engine.log.stampChanges(tx, seqBefore, txId);
+      await engine.log.updateColumnVersions(tx, seqBefore);
+    });
+    const newSeq = await engine.log.getLocalSeq();
+    if (newSeq > engine.lastLocalSeq) {
+      engine.lastLocalSeq = newSeq;
+    }
+    if (sawDdl) {
+      if (droppedTables.length > 0 && engine.tracker) {
+        await engine.tracker.pruneDroppedTables(engine.writerConn, droppedTables);
+      }
+      await engine.refreshTriggersAfterDdl();
+    }
+    return { results, requestId };
+  }
+  async executeTransactionLocally(fn, options) {
+    const ticket = this.transactionQueue.then(
+      () => this.runTransaction(fn, options),
+      () => this.runTransaction(fn, options)
+    );
+    this.transactionQueue = ticket.catch(() => void 0);
+    return ticket;
+  }
+  async runTransaction(fn, options) {
+    const engine = this.engine;
+    const txId = randomUUID();
+    const hooks = {
+      sawDdl: false,
+      droppedTables: [],
+      onDdl: () => {
+        throw new ReplicationError("Internal error: DDL hook invoked outside an active transaction");
+      }
+    };
+    const userResult = await engine.writerConn.transaction(async (tx) => {
+      const seqBefore = await engine.log.getLocalSeq();
+      hooks.onDdl = async (sql) => {
+        const droppedTable = extractDroppedTable(sql);
+        if (droppedTable !== null) {
+          hooks.droppedTables.push(droppedTable);
+        }
+        const ddlStmt = await tx.prepare(
+          `INSERT INTO "_sirannon_changes" (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);
+        if (engine.tracker) {
+          await engine.tracker.refreshAllTriggersUsingConnection(tx);
+        }
+      };
+      const replicationTx = new ReplicationTransaction(tx, hooks);
+      const result = await fn(replicationTx);
+      await engine.log.stampChanges(tx, seqBefore, txId);
+      await engine.log.updateColumnVersions(tx, seqBefore);
+      return result;
+    });
+    const newSeq = await engine.log.getLocalSeq();
+    if (newSeq > engine.lastLocalSeq) {
+      engine.lastLocalSeq = newSeq;
+    }
+    if (hooks.sawDdl) {
+      if (hooks.droppedTables.length > 0 && engine.tracker) {
+        await engine.tracker.pruneDroppedTables(engine.writerConn, hooks.droppedTables);
+      }
+      await engine.refreshTriggersAfterDdl();
+    }
+    const writeConcern = engine.resolveWriteConcern(options?.writeConcern);
+    if (writeConcern) {
+      await engine.waitForWriteConcern(newSeq, writeConcern);
+    }
+    return userResult;
+  }
+};
+
+// src/replication/engine/sender-loop.ts
+var SenderLoop = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  senderTimer = null;
+  start() {
+    const engine = this.engine;
+    if (!engine.running) return;
+    const timer = setTimeout(async () => {
+      if (!engine.running) return;
+      try {
+        engine.lastSentSeq = await engine.log.getLocalSeq();
+        await this.sendPendingBatches();
+        await this.updatePruneBoundary();
+      } catch (err) {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        engine.emitError({ error: wrappedErr, operation: "sender-loop", recoverable: true });
+      }
+      this.start();
+    }, engine.batchIntervalMs);
+    timer.unref?.();
+    this.senderTimer = timer;
+  }
+  stop() {
+    if (this.senderTimer !== null) {
+      clearTimeout(this.senderTimer);
+      this.senderTimer = null;
+    }
+  }
+  async updatePruneBoundary() {
+    const engine = this.engine;
+    if (!engine.tracker) return;
+    const minAcked = await engine.log.getMinAckedSeq();
+    if (minAcked === null) {
+      engine.tracker.clearPruneBoundary();
+    } else {
+      engine.tracker.setPruneBoundary(minAcked);
+    }
+  }
+  async sendPendingBatches() {
+    const engine = this.engine;
+    const peers = engine.config.transport.peers();
+    const nowMs = Date.now();
+    for (const [peerId, peerInfo] of peers) {
+      if (!this.shouldReplicateTo(peerId, peerInfo.role)) {
+        continue;
+      }
+      const peerState = engine.peerTracker.getPeerState(peerId);
+      if (peerState) {
+        engine.peerTracker.expireTimedOutBatches(peerId, nowMs, engine.ackTimeoutMs);
+      }
+      if (peerState && peerState.pendingBatches >= engine.maxPendingBatches) {
+        continue;
+      }
+      const fromSeq = peerState?.lastSentSeq ?? engine.lastSentSeq;
+      const rawBatch = await engine.log.readBatch(fromSeq, engine.batchSize);
+      if (!rawBatch) continue;
+      const batch = engine.decorateBatch(rawBatch);
+      const previousSeq = peerState?.lastSentSeq ?? 0n;
+      if (peerState) {
+        peerState.pendingBatches += 1;
+        peerState.lastSentSeq = batch.toSeq;
+        engine.peerTracker.recordInFlightBatch(peerId, {
+          batchId: batch.batchId,
+          fromSeq: batch.fromSeq,
+          toSeq: batch.toSeq,
+          sentAt: nowMs
+        });
+      }
+      engine.config.transport.send(peerId, batch).catch((err) => {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        engine.emitError({ error: wrappedErr, operation: "transport-send", peerId, recoverable: true });
+        if (peerState) {
+          const idx = peerState.inFlightBatches.findIndex((b) => b.batchId === batch.batchId);
+          if (idx >= 0) {
+            peerState.inFlightBatches.splice(idx, 1);
+          }
+          if (peerState.pendingBatches > 0) {
+            peerState.pendingBatches -= 1;
+          }
+          if (previousSeq < peerState.lastSentSeq) {
+            peerState.lastSentSeq = previousSeq;
+          }
+        }
+      });
+      if (engine.config.flowControl?.maxLagSeconds && peerState) {
+        const lagMs = Number(batch.toSeq - peerState.lastAckedSeq) * engine.batchIntervalMs;
+        const maxLagMs = engine.config.flowControl.maxLagSeconds * 1e3;
+        if (lagMs > maxLagMs && engine.config.flowControl.onLagExceeded) {
+          engine.config.flowControl.onLagExceeded(peerId, lagMs);
+        }
+      }
+    }
+  }
+  shouldReplicateTo(peerId, peerRole) {
+    const engine = this.engine;
+    if (!engine.isCoordinatorMode()) {
+      return engine.config.topology.shouldReplicateTo(peerId, peerRole);
+    }
+    return engine.coordinatorAuthority && peerId !== engine.nodeId;
+  }
+};
+
+// src/replication/engine/test-hooks.ts
+var ackDelayByEngine = /* @__PURE__ */ new WeakMap();
+function installTestHooks(engine) {
+  Object.defineProperty(engine, "__setAckDelayMs", {
+    value(ms) {
+      if (!Number.isFinite(ms) || ms < 0) {
+        throw new RangeError("ACK delay must be a non-negative finite number");
+      }
+      ackDelayByEngine.set(engine, Math.floor(ms));
+    },
+    enumerable: false
+  });
+}
+async function delayAckIfConfigured(engine) {
+  const delayMs = ackDelayByEngine.get(engine) ?? 0;
+  if (delayMs === 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, delayMs);
+    timer.unref?.();
+  });
+}
+
+// src/replication/engine/transport-wiring.ts
+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));
+    engine.emitError({ error: wrappedErr, operation: "ack-state-persist", peerId: nodeId, recoverable: true });
+  });
+}
+function wireTransportHandlers(engine) {
+  engine.config.transport.onBatchReceived(async (batch, fromPeerId) => {
+    if (!engine.running) return;
+    if (engine.syncState.phase !== "ready" && engine.syncState.phase !== "catching-up") return;
+    try {
+      if (batch.sourceNodeId !== fromPeerId) {
+        throw new BatchValidationError(
+          `Batch sourceNodeId '${batch.sourceNodeId}' does not match sender '${fromPeerId}'`
+        );
+      }
+      const knownPeers = engine.config.transport.peers();
+      if (!knownPeers.has(fromPeerId)) {
+        throw new BatchValidationError(`Batch from unknown peer: ${fromPeerId}`);
+      }
+      const peerInfo = knownPeers.get(fromPeerId);
+      if (!peerInfo || !engine.config.topology.shouldAcceptFrom(fromPeerId, peerInfo.role)) {
+        if (!engine.isCoordinatorMode()) {
+          throw new ReplicationError(`Rejected batch from unauthorized peer: ${fromPeerId}`);
+        }
+      }
+      await engine.assertInboundCoordinatorMessage(batch, fromPeerId, "batch");
+      if (batch.changes.length > engine.maxBatchChanges) {
+        throw new BatchValidationError(
+          `Batch too large: ${batch.changes.length} changes exceeds max ${engine.maxBatchChanges}`
+        );
+      }
+      const drift = engine.checkClockDrift(batch.hlcRange.max);
+      if (drift > engine.maxClockDriftMs) {
+        throw new BatchValidationError(`Clock drift too high: ${drift}ms exceeds max ${engine.maxClockDriftMs}ms`);
+      }
+      const applyResult = await engine.log.applyBatch(batch, (table) => engine.getResolver(table));
+      const batchContainedDdl = batch.changes.some((c) => c.operation === "ddl");
+      if (batchContainedDdl) {
+        if (applyResult.droppedTables.length > 0 && engine.tracker) {
+          await engine.tracker.pruneDroppedTables(engine.writerConn, applyResult.droppedTables);
+        }
+        await engine.refreshTriggersAfterDdl();
+      }
+      await engine.log.setLastAppliedSeq(fromPeerId, batch.toSeq);
+      const previousApplied = engine.appliedSeqByPeer.get(fromPeerId) ?? 0n;
+      if (batch.toSeq > previousApplied) {
+        engine.appliedSeqByPeer.set(fromPeerId, batch.toSeq);
+      }
+      if (batch.toSeq > engine.highestSourceSeqSeen) {
+        engine.highestSourceSeqSeen = batch.toSeq;
+      }
+      await delayAckIfConfigured(engine);
+      await engine.config.transport.sendAck(
+        fromPeerId,
+        engine.decorateAck({
+          batchId: batch.batchId,
+          ackedSeq: batch.toSeq,
+          nodeId: engine.nodeId
+        })
+      );
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "batch-received", peerId: fromPeerId, recoverable: true });
+    }
+  });
+  engine.config.transport.onAckReceived((ack, fromPeerId) => {
+    if (!engine.running) return;
+    if (engine.syncState.phase !== "ready" && engine.syncState.phase !== "catching-up") return;
+    if (!engine.isCoordinatorMode()) {
+      if (ack.nodeId !== fromPeerId) {
+        engine.emitError({
+          error: new ReplicationError(
+            `Ack nodeId '${ack.nodeId}' does not match sender '${fromPeerId}'`,
+            "ACK_NODE_ID_MISMATCH"
+          ),
+          operation: "ack-identity-mismatch",
+          peerId: fromPeerId,
+          recoverable: true
+        });
+        return;
+      }
+      engine.peerTracker.onAckReceived(ack.nodeId, ack.ackedSeq);
+      persistAckProgress(engine, ack.nodeId, ack.ackedSeq);
+      return;
+    }
+    engine.assertInboundCoordinatorMessage(ack, fromPeerId, "ack").then(() => {
+      engine.peerTracker.onAckReceived(ack.nodeId, ack.ackedSeq);
+      persistAckProgress(engine, ack.nodeId, ack.ackedSeq);
+    }).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "ack-received", peerId: fromPeerId, recoverable: true });
+    });
+  });
+  if (engine.config.topology.canWrite() || engine.isCoordinatorMode()) {
+    engine.config.transport.onForwardReceived(async (request, fromPeerId) => {
+      if (engine.syncState.phase !== "ready" && engine.syncState.phase !== "catching-up") {
+        throw new ReplicationError("Node is not ready to handle forwarded requests");
+      }
+      await engine.assertInboundCoordinatorMessage(request, fromPeerId, "forward");
+      const knownPeers = engine.config.transport.peers();
+      if (!knownPeers.has(fromPeerId)) {
+        throw new ReplicationError(`Rejected forward from unknown peer: ${fromPeerId}`);
+      }
+      try {
+        const result = await engine.localExecutor.executeForwardedLocally(request.statements);
+        return engine.decorateForwardResult(result);
+      } catch (err) {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        engine.emitError({ error: wrappedErr, operation: "forward-execution", peerId: fromPeerId, recoverable: true });
+        throw wrappedErr;
+      }
+    });
+  }
+  engine.config.transport.onPeerConnected((peer) => {
+    engine.peerTracker.addPeer(peer.id);
+    engine.log.getPeerAckedSeq(peer.id).then(async (ackedSeq) => {
+      if (!engine.running) return;
+      engine.peerTracker.onAckReceived(peer.id, ackedSeq);
+      await engine.log.setLastAppliedSeq(peer.id, ackedSeq);
+      await engine.handleCoordinatorAckProgress(peer.id, 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 });
+    });
+    if (engine.syncState.phase === "pending") {
+      engine.syncJoiner.initiateSync().catch((err) => {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        engine.emitError({ error: wrappedErr, operation: "sync-initiation", peerId: peer.id, recoverable: true });
+      });
+    }
+  });
+  engine.config.transport.onPeerDisconnected((peerId) => {
+    engine.peerTracker.removePeer(peerId);
+    engine.syncServer.abortSessionsForPeer(peerId);
+    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) => {
+        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.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 });
+      });
+    }
+  });
+  engine.config.transport.onSyncRequested(async (request, fromPeerId) => {
+    if (!engine.running) return;
+    await engine.assertInboundCoordinatorMessage(request, fromPeerId, "sync-request");
+    await engine.syncServer.handleSyncRequest(request, fromPeerId);
+  });
+  engine.config.transport.onSyncBatchReceived(async (batch, fromPeerId) => {
+    if (!engine.running) return;
+    await engine.assertInboundCoordinatorMessage(batch, fromPeerId, "sync-data");
+    await engine.syncJoiner.handleSyncBatchReceived(batch, fromPeerId);
+  });
+  engine.config.transport.onSyncCompleteReceived(async (complete, fromPeerId) => {
+    if (!engine.running) return;
+    await engine.assertInboundCoordinatorMessage(complete, fromPeerId, "sync-data");
+    await engine.syncJoiner.handleSyncCompleteReceived(complete, fromPeerId);
+  });
+  engine.config.transport.onSyncAckReceived((ack, fromPeerId) => {
+    if (!engine.running) return;
+    if (!engine.isCoordinatorMode()) {
+      if (ack.joinerNodeId !== fromPeerId) {
+        engine.emitError({
+          error: new ReplicationError(
+            `SyncAck joinerNodeId '${ack.joinerNodeId}' does not match sender '${fromPeerId}'`,
+            "SYNC_ACK_NODE_ID_MISMATCH"
+          ),
+          operation: "sync-ack-identity-mismatch",
+          peerId: fromPeerId,
+          recoverable: true
+        });
+        return;
+      }
+      engine.syncServer.handleSyncAckReceived(ack);
+      return;
+    }
+    engine.assertInboundCoordinatorMessage(ack, fromPeerId, "ack").then(() => {
+      engine.syncServer.handleSyncAckReceived(ack);
+    }).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "sync-ack-received", peerId: fromPeerId, recoverable: true });
+    });
+  });
+}
+
+// src/replication/engine/startup.ts
+async function recoverHlcFromDurableState(engine) {
+  const maxObserved = await engine.log.recoverMaxObservedHlc();
+  if (maxObserved === null) return;
+  engine.hlc.receive(maxObserved);
+}
+async function startEngine(engine) {
+  if (engine.running) return;
+  engine.running = true;
+  await engine.log.ensureReplicationTables();
+  await recoverHlcFromDurableState(engine);
+  engine.lastSentSeq = await engine.log.getLocalSeq();
+  engine.lastLocalSeq = engine.lastSentSeq;
+  await engine.loadAppliedSeqs();
+  await engine.startCoordinatorMode();
+  await engine.prepareCoordinatorRejoinIfNeeded();
+  wireTransportHandlers(engine);
+  const transportConfig = {
+    ...engine.config.transportConfig,
+    localRole: engine.config.topology.role,
+    groupId: engine.config.coordinator?.groupId ?? engine.config.transportConfig?.groupId,
+    primaryTerm: engine.coordinatorState?.primaryTerm ?? engine.config.transportConfig?.primaryTerm,
+    protocolVersion: engine.config.coordinator?.compatibility?.protocolVersion ?? engine.config.transportConfig?.protocolVersion
+  };
+  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 savedState = await engine.log.getSyncState();
+    if (savedState.phase === "syncing") {
+      if (!engine.tracker) {
+        throw new SyncError("Initial sync requires a ChangeTracker in ReplicationConfig");
+      }
+      await engine.log.wipeTables(
+        engine.writerConn,
+        await engine.log.getTablesInFkOrder(engine.writerConn),
+        engine.tracker
+      );
+    }
+    engine.syncState = {
+      phase: "pending",
+      sourcePeerId: null,
+      snapshotSeq: null,
+      completedTables: [],
+      totalTables: 0,
+      startedAt: null,
+      error: null
+    };
+    await engine.log.setSyncMeta("pending");
+    await engine.syncJoiner.initiateSync();
+    return;
+  }
+  if (engine.initialSync && !isPrimary && syncCompleted) {
+    const savedState = await engine.log.getSyncState();
+    if (savedState.phase === "catching-up") {
+      engine.syncState = {
+        phase: "catching-up",
+        sourcePeerId: savedState.sourcePeerId,
+        snapshotSeq: savedState.snapshotSeq,
+        completedTables: [],
+        totalTables: 0,
+        startedAt: null,
+        error: null
+      };
+      engine.startSenderLoop();
+      engine.syncJoiner.startCatchUpCheck();
+      return;
+    }
+    engine.syncState.phase = "ready";
+  }
+  if (!engine.initialSync && engine.resumeFromSeq !== void 0) {
+    engine.lastSentSeq = engine.resumeFromSeq;
+    await engine.log.setSyncMeta("ready", engine.resumeFromSeq);
+    engine.syncState.phase = "ready";
+  } else if (!engine.initialSync && !syncCompleted) {
+    const localSeq = await engine.log.getLocalSeq();
+    if (localSeq > 0n) {
+      await engine.log.setSyncMeta("ready", localSeq);
+    }
+    engine.syncState.phase = "ready";
+  } else {
+    engine.syncState.phase = "ready";
+  }
+  engine.startSenderLoop();
+}
+var SyncJoiner = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  catchUpCheckTimer = null;
+  async initiateSync() {
+    const engine = this.engine;
+    if (engine.syncState.phase !== "pending") return;
+    if (!engine.tracker) {
+      throw new SyncError("Initial sync requires a ChangeTracker in ReplicationConfig");
+    }
+    const peers = engine.config.transport.peers();
+    let sourcePeerId = engine.isCoordinatorMode() ? engine.getCurrentPrimaryPeerId() : null;
+    if (engine.isCoordinatorMode() && sourcePeerId === null) {
+      return;
+    }
+    if (sourcePeerId === null) {
+      for (const [peerId, info] of peers) {
+        if (info.role === "primary") {
+          sourcePeerId = peerId;
+          break;
+        }
+      }
+    }
+    if (sourcePeerId === null) {
+      for (const [peerId] of peers) {
+        sourcePeerId = peerId;
+        break;
+      }
+    }
+    if (sourcePeerId === null) {
+      return;
+    }
+    engine.syncState.phase = "syncing";
+    engine.syncState.sourcePeerId = sourcePeerId;
+    engine.syncState.startedAt = Date.now();
+    engine.syncState.error = null;
+    try {
+      const savedState = await engine.log.getSyncState();
+      const completedTables = savedState.phase === "pending" ? [] : savedState.completedTables;
+      const requestId = randomUUID();
+      await engine.log.setSyncMeta("syncing", void 0, sourcePeerId, requestId);
+      await engine.config.transport.requestSync(
+        sourcePeerId,
+        engine.decorateSyncRequest({
+          requestId,
+          joinerNodeId: engine.nodeId,
+          completedTables
+        })
+      );
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      if (engine.syncState.phase === "syncing" && engine.syncState.sourcePeerId === sourcePeerId) {
+        engine.syncState.phase = "pending";
+        engine.syncState.sourcePeerId = null;
+        engine.syncState.startedAt = null;
+        engine.syncState.error = wrappedErr.message;
+        try {
+          await engine.log.setSyncMeta("pending");
+        } catch (rollbackErr) {
+          const wrappedRollbackErr = rollbackErr instanceof Error ? rollbackErr : new Error(String(rollbackErr));
+          engine.emitError({
+            error: wrappedRollbackErr,
+            operation: "sync-request-state-rollback",
+            peerId: sourcePeerId,
+            recoverable: false
+          });
+        }
+      }
+      throw wrappedErr;
+    }
+  }
+  async handleSyncBatchReceived(batch, fromPeerId) {
+    const engine = this.engine;
+    if (engine.syncState.phase !== "syncing") return;
+    if (fromPeerId !== engine.syncState.sourcePeerId) return;
+    if (!engine.tracker) {
+      throw new SyncError("Initial sync requires a ChangeTracker in ReplicationConfig");
+    }
+    const expectedIndex = engine.expectedBatchIndex.get(batch.table) ?? 0;
+    if (batch.batchIndex !== expectedIndex) {
+      await this.sendSyncAck(fromPeerId, {
+        requestId: batch.requestId,
+        joinerNodeId: engine.nodeId,
+        table: batch.table,
+        batchIndex: batch.batchIndex,
+        success: false,
+        error: `Out of order batch: expected ${expectedIndex}, got ${batch.batchIndex}`
+      });
+      return;
+    }
+    engine.expectedBatchIndex.set(batch.table, expectedIndex + 1);
+    try {
+      if (batch.table === "__schema__") {
+        if (batch.schema) {
+          for (const ddl of batch.schema) {
+            if (!isSyncSafeDdl(ddl)) {
+              throw new SyncError(`Unsafe DDL in schema batch: ${ddl}`);
+            }
+          }
+          await engine.writerConn.exec("PRAGMA foreign_keys = OFF");
+          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");
+            await engine.writerConn.exec(saferDdl);
+          }
+        }
+        await this.sendSyncAck(fromPeerId, {
+          requestId: batch.requestId,
+          joinerNodeId: engine.nodeId,
+          table: batch.table,
+          batchIndex: batch.batchIndex,
+          success: true
+        });
+        return;
+      }
+      if (!IDENTIFIER_RE.test(batch.table)) {
+        throw new SyncError(`Invalid table name in sync batch: ${batch.table}`);
+      }
+      const expectedChecksum = createHash("sha256").update(canonicaliseForChecksum(batch.rows)).digest("hex");
+      if (batch.checksum !== expectedChecksum) {
+        throw new SyncError(`Checksum mismatch for ${batch.table} batch ${batch.batchIndex}`);
+      }
+      if (batch.batchIndex === 0 && !engine.syncState.completedTables.includes(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);
+            }
+          });
+        }
+      }
+      if (batch.isLastBatchForTable) {
+        await engine.log.setSyncTableStatus(batch.table, "completed");
+        engine.syncState.completedTables.push(batch.table);
+        engine.expectedBatchIndex.delete(batch.table);
+      }
+      await this.sendSyncAck(fromPeerId, {
+        requestId: batch.requestId,
+        joinerNodeId: engine.nodeId,
+        table: batch.table,
+        batchIndex: batch.batchIndex,
+        success: true
+      });
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "sync-batch-processing", peerId: fromPeerId, recoverable: true });
+      await this.sendSyncAck(fromPeerId, {
+        requestId: batch.requestId,
+        joinerNodeId: engine.nodeId,
+        table: batch.table,
+        batchIndex: batch.batchIndex,
+        success: false,
+        error: wrappedErr.message
+      }).catch((ackErr) => {
+        const ackWrapped = ackErr instanceof Error ? ackErr : new Error(String(ackErr));
+        engine.emitError({ error: ackWrapped, operation: "sync-ack-send", peerId: fromPeerId, recoverable: true });
+      });
+    }
+  }
+  async handleSyncCompleteReceived(complete, fromPeerId) {
+    const engine = this.engine;
+    if (engine.syncState.phase !== "syncing") return;
+    if (fromPeerId !== engine.syncState.sourcePeerId) return;
+    if (!engine.tracker) {
+      throw new SyncError("Initial sync requires a ChangeTracker in ReplicationConfig");
+    }
+    try {
+      for (const manifest of complete.manifests) {
+        if (IDENTIFIER_RE.test(manifest.table)) {
+          await engine.tracker.watch(engine.writerConn, manifest.table);
+        }
+      }
+      await engine.writerConn.exec("PRAGMA foreign_keys = ON");
+      for (const manifest of complete.manifests) {
+        const valid = 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)),
+            engine.tracker
+          );
+          engine.syncState.phase = "pending";
+          engine.syncState.completedTables = [];
+          engine.expectedBatchIndex.clear();
+          await engine.log.setSyncMeta("pending");
+          await this.initiateSync();
+          return;
+        }
+      }
+      await engine.log.setLastAppliedSeq(fromPeerId, complete.snapshotSeq);
+      const recordStmt = await engine.writerConn.prepare(
+        "INSERT OR IGNORE INTO _sirannon_applied_changes (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)"
+      );
+      await recordStmt.run(fromPeerId, complete.snapshotSeq.toString(), Date.now() / 1e3);
+      const previousApplied = engine.appliedSeqByPeer.get(fromPeerId) ?? 0n;
+      if (complete.snapshotSeq > previousApplied) {
+        engine.appliedSeqByPeer.set(fromPeerId, complete.snapshotSeq);
+      }
+      engine.syncState.phase = "catching-up";
+      engine.syncState.snapshotSeq = complete.snapshotSeq;
+      await engine.log.setSyncMeta("catching-up", complete.snapshotSeq);
+      engine.startSenderLoop();
+      this.startCatchUpCheck();
+    } catch {
+      try {
+        await engine.writerConn.exec("PRAGMA foreign_keys = ON");
+      } catch (pragmaErr) {
+        const wrappedErr = pragmaErr instanceof Error ? pragmaErr : new Error(String(pragmaErr));
+        engine.emitError({ error: wrappedErr, operation: "sync-complete-pragma-restore", recoverable: false });
+      }
+      engine.emitError({
+        error: new SyncError("Failed during sync completion handling"),
+        operation: "sync-complete-handling",
+        recoverable: false
+      });
+      return;
+    }
+  }
+  startCatchUpCheck() {
+    const engine = this.engine;
+    const catchUpStartedAt = Date.now();
+    this.catchUpCheckTimer = setInterval(async () => {
+      if (engine.syncState.phase !== "catching-up") {
+        this.stopCatchUpCheck();
+        return;
+      }
+      if (Date.now() - catchUpStartedAt > engine.catchUpDeadlineMs) {
+        await this.finishCatchUpAsReady();
+        return;
+      }
+      const sourcePeerId = engine.syncState.sourcePeerId;
+      if (!sourcePeerId) return;
+      if (engine.highestSourceSeqSeen === 0n) {
+        const snapshotSeq = engine.syncState.snapshotSeq ?? 0n;
+        if (snapshotSeq === 0n) {
+          await this.finishCatchUpAsReady();
+          return;
+        }
+        const localSeq = await engine.log.getLocalSeq();
+        if (localSeq === 0n) {
+          await this.finishCatchUpAsReady();
+          return;
+        }
+        return;
+      }
+      const appliedSeq = await engine.log.getLastAppliedSeq(sourcePeerId);
+      const lag = engine.highestSourceSeqSeen - appliedSeq;
+      if (lag <= BigInt(engine.maxSyncLagBeforeReady)) {
+        await this.finishCatchUpAsReady();
+      }
+    }, engine.batchIntervalMs * 2);
+  }
+  stopCatchUpCheck() {
+    if (this.catchUpCheckTimer) {
+      clearInterval(this.catchUpCheckTimer);
+      this.catchUpCheckTimer = null;
+    }
+  }
+  async sendSyncAck(peerId, ack) {
+    await delayAckIfConfigured(this.engine);
+    await this.engine.config.transport.sendSyncAck(peerId, this.engine.decorateSyncAck(ack));
+  }
+  async finishCatchUpAsReady() {
+    const engine = this.engine;
+    await engine.log.setSyncMeta("ready");
+    await engine.markCoordinatorSyncReady();
+    engine.syncState.phase = "ready";
+    this.stopCatchUpCheck();
+  }
+};
+var SyncServer = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  activeSyncs = /* @__PURE__ */ new Map();
+  syncAckWaiters = /* @__PURE__ */ new Map();
+  async handleSyncRequest(request, fromPeerId) {
+    const engine = this.engine;
+    const knownPeers = engine.config.transport.peers();
+    if (!knownPeers.has(fromPeerId)) return;
+    if (engine.isCoordinatorMode()) {
+      try {
+        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
+          })
+        );
+        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"
+        })
+      );
+      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"
+        })
+      );
+      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"
+        })
+      );
+      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"
+        })
+      );
+      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}`
+          })
+        );
+        return;
+      }
+    }
+    let readConn;
+    try {
+      readConn = await engine.snapshotConnectionFactory();
+    } catch (err) {
+      await engine.config.transport.sendSyncAck(
+        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)}`
+        })
+      );
+      return;
+    }
+    const snapshotSeq = await engine.log.getLocalSeq();
+    await readConn.exec("BEGIN");
+    const lockStmt = await readConn.prepare("SELECT 1 FROM sqlite_master LIMIT 1");
+    await lockStmt.get();
+    engine.log.registerActiveSyncSeq(snapshotSeq);
+    const allTables = await engine.log.getTablesInFkOrder(readConn);
+    const completedSet = new Set(request.completedTables);
+    const tables = allTables.filter((t) => !completedSet.has(t));
+    const timeoutTimer = setTimeout(
+      () => this.abortSyncSession(request.requestId),
+      engine.maxSyncDurationMs
+    );
+    timeoutTimer.unref?.();
+    const session = {
+      requestId: request.requestId,
+      joinerNodeId: request.joinerNodeId,
+      readConn,
+      snapshotSeq,
+      tables,
+      completedTables: new Set(request.completedTables),
+      startedAt: Date.now(),
+      timeoutTimer,
+      aborted: false
+    };
+    this.activeSyncs.set(request.requestId, session);
+    this.serveSyncSession(session).catch((err) => {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({ error: wrappedErr, operation: "sync-session-serve", peerId: fromPeerId, recoverable: true });
+      this.abortSyncSession(request.requestId);
+    });
+  }
+  handleSyncAckReceived(ack) {
+    const key = `${ack.requestId}:${ack.table}:${ack.batchIndex}`;
+    const waiter = this.syncAckWaiters.get(key);
+    if (waiter) {
+      this.syncAckWaiters.delete(key);
+      clearTimeout(waiter.timer);
+      waiter.resolve(ack);
+    }
+  }
+  abortSyncSession(requestId) {
+    const session = this.activeSyncs.get(requestId);
+    if (!session) return;
+    session.aborted = true;
+    for (const [key, waiter] of this.syncAckWaiters) {
+      if (key.startsWith(`${requestId}:`)) {
+        this.syncAckWaiters.delete(key);
+        clearTimeout(waiter.timer);
+        waiter.resolve({
+          requestId,
+          joinerNodeId: session.joinerNodeId,
+          table: "",
+          batchIndex: -1,
+          success: false,
+          error: "Session aborted"
+        });
+      }
+    }
+    try {
+      session.readConn.close().catch((err) => {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        this.engine.emitError({
+          error: wrappedErr,
+          operation: "sync-session-abort-close",
+          peerId: session.joinerNodeId,
+          recoverable: true
+        });
+      });
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      this.engine.emitError({
+        error: wrappedErr,
+        operation: "sync-session-abort-close",
+        peerId: session.joinerNodeId,
+        recoverable: true
+      });
+    }
+    this.engine.log.unregisterActiveSyncSeq(session.snapshotSeq);
+    this.activeSyncs.delete(requestId);
+    clearTimeout(session.timeoutTimer);
+  }
+  abortAll() {
+    for (const [requestId] of this.activeSyncs) {
+      this.abortSyncSession(requestId);
+    }
+  }
+  abortSessionsForPeer(peerId) {
+    for (const [requestId, session] of this.activeSyncs) {
+      if (session.joinerNodeId === peerId) {
+        this.abortSyncSession(requestId);
+      }
+    }
+  }
+  waitForSyncAck(requestId, table, batchIndex) {
+    return new Promise((resolve, reject) => {
+      const key = `${requestId}:${table}:${batchIndex}`;
+      const timer = setTimeout(() => {
+        this.syncAckWaiters.delete(key);
+        reject(new SyncError(`Sync ack timeout for ${table} batch ${batchIndex}`, requestId));
+      }, this.engine.syncAckTimeoutMs);
+      timer.unref?.();
+      this.syncAckWaiters.set(key, {
+        resolve: (ack) => {
+          resolve(ack);
+        },
+        timer
+      });
+    });
+  }
+  async sendSyncBatchAndWaitForAck(peerId, batch) {
+    const ackPromise = this.waitForSyncAck(batch.requestId, batch.table, batch.batchIndex);
+    try {
+      await this.engine.config.transport.sendSyncBatch(peerId, this.engine.decorateSyncBatch(batch));
+    } catch (err) {
+      const key = `${batch.requestId}:${batch.table}:${batch.batchIndex}`;
+      const waiter = this.syncAckWaiters.get(key);
+      if (waiter) {
+        this.syncAckWaiters.delete(key);
+        clearTimeout(waiter.timer);
+        waiter.resolve({
+          requestId: batch.requestId,
+          joinerNodeId: peerId,
+          table: batch.table,
+          batchIndex: batch.batchIndex,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      await ackPromise;
+      throw err;
+    }
+    return ackPromise;
+  }
+  async serveSyncSession(session) {
+    const engine = this.engine;
+    const schemaDdl = await engine.log.dumpSchema(session.readConn);
+    const schemaChecksum = createHash("sha256").update(canonicaliseForChecksum(schemaDdl)).digest("hex");
+    const schemaAck = await this.sendSyncBatchAndWaitForAck(session.joinerNodeId, {
+      requestId: session.requestId,
+      table: "__schema__",
+      batchIndex: 0,
+      rows: [],
+      schema: schemaDdl,
+      checksum: schemaChecksum,
+      isLastBatchForTable: true
+    });
+    if (!schemaAck.success) {
+      this.abortSyncSession(session.requestId);
+      return;
+    }
+    for (const table of session.tables) {
+      if (session.aborted) return;
+      let batchIndex = 0;
+      for await (const { rows, checksum, isLast } of engine.log.dumpTableOnConnection(
+        session.readConn,
+        table,
+        engine.syncBatchSize
+      )) {
+        if (session.aborted) return;
+        const ack = await this.sendSyncBatchAndWaitForAck(session.joinerNodeId, {
+          requestId: session.requestId,
+          table,
+          batchIndex,
+          rows,
+          checksum,
+          isLastBatchForTable: isLast
+        });
+        if (!ack.success) {
+          this.abortSyncSession(session.requestId);
+          return;
+        }
+        batchIndex += 1;
+      }
+      if (batchIndex === 0) {
+        const emptyAck = await this.sendSyncBatchAndWaitForAck(session.joinerNodeId, {
+          requestId: session.requestId,
+          table,
+          batchIndex: 0,
+          rows: [],
+          checksum: createHash("sha256").update(canonicaliseForChecksum([])).digest("hex"),
+          isLastBatchForTable: true
+        });
+        if (!emptyAck.success) {
+          this.abortSyncSession(session.requestId);
+          return;
+        }
+      }
+      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));
+    }
+    await engine.config.transport.sendSyncComplete(
+      session.joinerNodeId,
+      engine.decorateSyncComplete({
+        requestId: session.requestId,
+        snapshotSeq: session.snapshotSeq,
+        manifests
+      })
+    );
+    try {
+      await session.readConn.exec("COMMIT");
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({
+        error: wrappedErr,
+        operation: "sync-session-commit",
+        peerId: session.joinerNodeId,
+        recoverable: true
+      });
+    }
+    try {
+      await session.readConn.close();
+    } catch (err) {
+      const wrappedErr = err instanceof Error ? err : new Error(String(err));
+      engine.emitError({
+        error: wrappedErr,
+        operation: "sync-session-close",
+        peerId: session.joinerNodeId,
+        recoverable: true
+      });
+    }
+    engine.log.unregisterActiveSyncSeq(session.snapshotSeq);
+    clearTimeout(session.timeoutTimer);
+    this.activeSyncs.delete(session.requestId);
+  }
+};
+
+// 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;
+  config;
+  nodeId;
+  hlc;
+  log;
+  peerTracker = new PeerTracker();
+  defaultResolver;
+  tracker;
+  snapshotConnectionFactory;
+  batchSize;
+  batchIntervalMs;
+  maxClockDriftMs;
+  maxPendingBatches;
+  maxBatchChanges;
+  ackTimeoutMs;
+  initialSync;
+  syncBatchSize;
+  maxConcurrentSyncs;
+  maxSyncDurationMs;
+  maxSyncLagBeforeReady;
+  syncAckTimeoutMs;
+  catchUpDeadlineMs;
+  resumeFromSeq;
+  running = false;
+  coordinatorState = null;
+  coordinatorAuthority = false;
+  controllerState = "disabled";
+  nodeSessionLeaseId = null;
+  controllerLeaseId = null;
+  coordinatorWatchDisposer = null;
+  coordinatorLeaseTimer = null;
+  controllerTimer = null;
+  coordinatorRejoinSyncStarting = false;
+  lastSentSeq = 0n;
+  lastLocalSeq = 0n;
+  highestSourceSeqSeen = 0n;
+  appliedSeqByPeer = /* @__PURE__ */ new Map();
+  expectedBatchIndex = /* @__PURE__ */ new Map();
+  syncState = {
+    phase: "ready",
+    sourcePeerId: null,
+    snapshotSeq: null,
+    completedTables: [],
+    totalTables: 0,
+    startedAt: null,
+    error: null
+  };
+  localExecutor;
+  syncServer;
+  syncJoiner;
+  senderLoop;
+  constructor(database, writerConn, config) {
+    super();
+    this.database = database;
+    this.writerConn = writerConn;
+    this.config = config;
+    if (config.coordinator && !config.nodeId) {
+      throw new AuthorityError("Coordinator mode requires a stable persisted nodeId");
+    }
+    this.nodeId = config.nodeId ?? generateNodeId();
+    this.hlc = new HLC(this.nodeId);
+    this.tracker = config.changeTracker;
+    this.log = new ReplicationLog(writerConn, this.nodeId, this.hlc, "_sirannon_changes", this.tracker);
+    this.defaultResolver = config.defaultConflictResolver ?? new LWWResolver();
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.batchIntervalMs = config.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
+    this.maxClockDriftMs = config.maxClockDriftMs ?? DEFAULT_MAX_CLOCK_DRIFT_MS;
+    this.maxPendingBatches = config.maxPendingBatches ?? DEFAULT_MAX_PENDING_BATCHES;
+    this.maxBatchChanges = config.maxBatchChanges ?? DEFAULT_MAX_BATCH_CHANGES;
+    this.ackTimeoutMs = config.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS;
+    this.initialSync = config.initialSync ?? true;
+    this.syncBatchSize = config.syncBatchSize ?? DEFAULT_SYNC_BATCH_SIZE;
+    this.maxConcurrentSyncs = config.maxConcurrentSyncs ?? DEFAULT_MAX_CONCURRENT_SYNCS;
+    this.maxSyncDurationMs = config.maxSyncDurationMs ?? DEFAULT_MAX_SYNC_DURATION_MS;
+    this.maxSyncLagBeforeReady = config.maxSyncLagBeforeReady ?? DEFAULT_MAX_SYNC_LAG_BEFORE_READY;
+    this.syncAckTimeoutMs = config.syncAckTimeoutMs ?? DEFAULT_SYNC_ACK_TIMEOUT_MS;
+    this.catchUpDeadlineMs = config.catchUpDeadlineMs ?? DEFAULT_CATCH_UP_DEADLINE_MS;
+    this.resumeFromSeq = config.resumeFromSeq;
+    this.snapshotConnectionFactory = config.snapshotConnectionFactory;
+    this.localExecutor = new LocalExecutor(this);
+    this.syncServer = new SyncServer(this);
+    this.syncJoiner = new SyncJoiner(this);
+    this.senderLoop = new SenderLoop(this);
+    installTestHooks(this);
+  }
+  start() {
+    return startEngine(this);
+  }
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    this.stopCoordinatorTimers();
+    this.syncJoiner.stopCatchUpCheck();
+    this.syncServer.abortAll();
+    if (this.syncState.phase === "syncing") {
+      try {
+        await this.writerConn.exec("PRAGMA foreign_keys = ON");
+      } catch (err) {
+        const wrappedErr = err instanceof Error ? err : new Error(String(err));
+        this.emitError({ error: wrappedErr, operation: "engine-stop-pragma-restore", recoverable: false });
+      }
+    }
+    this.senderLoop.stop();
+    if (this.tracker) {
+      this.tracker.clearPruneBoundary();
+    }
+    await this.stopCoordinatorMode();
+    await this.config.transport.disconnect();
+  }
+  status() {
+    return {
+      nodeId: this.nodeId,
+      role: this.config.topology.role,
+      peers: this.peerTracker.allPeerStates(),
+      localSeq: this.lastSentSeq,
+      replicating: this.running,
+      syncState: { ...this.syncState },
+      coordinator: this.getCoordinatorRuntimeStatus()
+    };
+  }
+  getCurrentSeq() {
+    return this.lastLocalSeq;
+  }
+  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);
+  }
+  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);
+  }
+  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;
+  }
+  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);
+  }
+  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()
+    });
+  }
+  startSenderLoop() {
+    this.senderLoop.start();
+  }
+  emitError(event) {
+    if (this.listenerCount("replication-error") > 0) {
+      try {
+        this.emit("replication-error", event);
+      } catch {
+      }
+    }
+  }
+  getResolver(table) {
+    if (table && this.config.conflictResolvers) {
+      const specific = this.config.conflictResolvers[table];
+      if (specific) return specific;
+    }
+    return this.defaultResolver;
+  }
+  checkClockDrift(remoteHlc) {
+    const decoded = HLC.decode(remoteHlc);
+    return Math.abs(Date.now() - decoded.wallMs);
+  }
+  async refreshTriggersAfterDdl() {
+    if (!this.tracker) return;
+    const tables = Array.from(this.tracker.watchedTables);
+    for (const table of tables) {
+      try {
+        await this.tracker.watch(this.writerConn, table);
+      } catch {
+      }
+    }
+  }
+  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);
+    }
+  }
+  async loadAppliedSeqs() {
+    const stmt = await this.writerConn.prepare(
+      "SELECT source_node_id, MAX(source_seq) AS max_seq FROM _sirannon_applied_changes 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));
+    }
+  }
+  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();
+  }
+  async prepareCoordinatorRejoinIfNeeded() {
+    const state = this.coordinatorState ?? await this.refreshCoordinatorState();
+    if (!state || !this.requiresCoordinatorRejoin(state)) return;
+    await this.evaluateFormerPrimaryHistory(state);
+  }
+  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);
+  }
+  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;
+  }
+  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)
+      );
+    }
+  }
+  decorateBatch(batch) {
+    return { ...batch, ...this.getCoordinatorMessageFields() };
+  }
+  decorateAck(ack) {
+    return { ...ack, ...this.getCoordinatorMessageFields() };
+  }
+  decorateForwardResult(result) {
+    return { ...result, ...this.getCoordinatorMessageFields() };
+  }
+  decorateSyncRequest(request) {
+    return { ...request, ...this.getCoordinatorMessageFields() };
+  }
+  decorateSyncBatch(batch) {
+    return { ...batch, ...this.getCoordinatorMessageFields() };
+  }
+  decorateSyncComplete(complete) {
+    return { ...complete, ...this.getCoordinatorMessageFields() };
+  }
+  decorateSyncAck(ack) {
+    return { ...ack, ...this.getCoordinatorMessageFields() };
+  }
+  resolveWriteConcern(wc) {
+    if (wc) return wc;
+    if (this.isCoordinatorMode()) {
+      return { level: "majority" };
+    }
+    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
+    };
+  }
+};
+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 {
+  role;
+  constructor(role) {
+    this.role = role;
+  }
+  canWrite() {
+    return this.role === "primary";
+  }
+  shouldReplicateTo(_peerId, peerRole) {
+    return this.role === "primary" && peerRole === "replica";
+  }
+  shouldAcceptFrom(_peerId, peerRole) {
+    return this.role === "replica" && peerRole === "primary";
+  }
+  requiresConflictResolution() {
+    return false;
+  }
+};
+
+export { FieldMergeResolver, HLC, LWWResolver, PeerTracker, PrimaryReplicaTopology, PrimaryWinsResolver, ReplicationEngine, ReplicationLog, generateNodeId, validateNodeId };