@delali/sirannon-db 0.1.8 → 0.2.1-next.18

package/dist/chunk-P2VJYRVY.mjs

@@ -0,0 +1,714 @@
+import { query, execute, executeBatch } from './chunk-HCCGEIZ2.mjs';
+import { ensureMetaTable, selectMetaValue, IDENTIFIER_RE, selectAppliedSourceSeqsInRange, prepareInsertAppliedChange, validateDdlSafety, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareDeleteRowColumnVersionsUpToHlc, canonicaliseForChecksum, prepareUpsertNewerColumnVersion, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion } from './chunk-7FQRQH5Z.mjs';
+import { ReplicationError, BatchValidationError } from './chunk-2QLXDHAP.mjs';
+import { CHANGES_TABLE, decodeTaggedValues } from './chunk-7R4ER4FB.mjs';
+import { sha256Hex } from './chunk-GVCNMPOS.mjs';
+
+// src/core/transaction.ts
+var Transaction = class _Transaction {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  _lastInsertRowId = 0;
+  /**
+   * Runs a read inside this transaction.
+   *
+   * @param sql - The statement to run.
+   * @param params - Values bound to the statement, named or positional.
+   * @returns The rows the statement produced.
+   */
+  async query(sql, params) {
+    return query(this.conn, sql, params);
+  }
+  /**
+   * Runs one write inside this transaction.
+   *
+   * @param sql - The statement to run.
+   * @param params - Values bound to the statement, named or positional.
+   * @returns How many rows changed, and the last inserted row id.
+   */
+  async execute(sql, params) {
+    const result = await execute(this.conn, sql, params);
+    this._lastInsertRowId = result.lastInsertRowId;
+    return result;
+  }
+  /**
+   * Runs one statement over many parameter sets inside this transaction.
+   *
+   * @param sql - The statement to run for each parameter set.
+   * @param paramsBatch - One parameter set per run.
+   * @returns One result per parameter set, in order.
+   */
+  async executeBatch(sql, paramsBatch) {
+    const results = await executeBatch(this.conn, sql, paramsBatch);
+    if (results.length > 0) {
+      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
+    }
+    return results;
+  }
+  /**
+   * Row id SQLite assigned to the last row this transaction inserted.
+   */
+  get lastInsertRowId() {
+    return this._lastInsertRowId;
+  }
+  /** @internal */
+  static async run(conn, fn) {
+    return conn.transaction(async (txConn) => {
+      const tx = new _Transaction(txConn);
+      return fn(tx);
+    });
+  }
+};
+
+// src/core/sync/hlc.ts
+var MAX_LOGICAL = 65535;
+var HLC = class _HLC {
+  wallMs;
+  logical;
+  nodeId;
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.wallMs = 0;
+    this.logical = 0;
+  }
+  /**
+   * Generate a new HLC timestamp, advancing the clock.
+   *
+   * @internal
+   */
+  now() {
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
+    } else {
+      this.logical += 1;
+      if (this.logical > MAX_LOGICAL) {
+        throw new ReplicationError("HLC logical counter overflow");
+      }
+    }
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
+  }
+  /**
+   * Merge a remote HLC timestamp into the local clock and return the updated value.
+   *
+   * @internal
+   */
+  receive(remote) {
+    const r = _HLC.decode(remote);
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs && physicalMs > r.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
+    } else if (r.wallMs > this.wallMs) {
+      this.wallMs = r.wallMs;
+      this.logical = r.logical + 1;
+    } else if (this.wallMs > r.wallMs) {
+      this.logical += 1;
+    } else {
+      this.logical = Math.max(this.logical, r.logical) + 1;
+    }
+    if (this.logical > MAX_LOGICAL) {
+      throw new ReplicationError("HLC logical counter overflow");
+    }
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
+  }
+  /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
+  static compare(a, b) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
+  static decode(hlc) {
+    const parts = hlc.split("-");
+    if (parts.length < 3) {
+      throw new ReplicationError(`Invalid HLC format: ${hlc}`);
+    }
+    return {
+      wallMs: Number.parseInt(parts[0], 16),
+      logical: Number.parseInt(parts[1], 16),
+      nodeId: parts.slice(2).join("-")
+    };
+  }
+  /**
+   * Builds the string form of a clock reading, which sorts in the same order as the reading itself.
+   *
+   * @param wallMs - Wall-clock milliseconds since the Unix epoch.
+   * @param logical - Counter that orders events sharing one millisecond.
+   * @param nodeId - Identifier of the node taking the reading.
+   * @returns The encoded stamp.
+   */
+  static encode(wallMs, logical, nodeId) {
+    const wallHex = wallMs.toString(16).padStart(12, "0");
+    const logicalHex = logical.toString(16).padStart(4, "0");
+    return `${wallHex}-${logicalHex}-${nodeId}`;
+  }
+};
+
+// src/core/sync/conflict/lww.ts
+var LWWResolver = class {
+  /**
+   * Takes the incoming row when its stamp is higher, and keeps the local row otherwise.
+   *
+   * @param ctx - The local and incoming versions of one row.
+   * @returns Which version to write.
+   */
+  resolve(ctx) {
+    if (ctx.remoteChange.operation === "delete") {
+      return { action: "accept_remote" };
+    }
+    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/core/sync/checksum.ts
+function computeChecksum(changes) {
+  return sha256Hex(canonicaliseForChecksum(changes));
+}
+
+// src/core/sync/hlc-store.ts
+var HLC_CLOCK_META_KEY = "hlc_clock";
+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;
+}
+async function persistHlcClock(conn, encoded) {
+  await ensureMetaTable(conn);
+  await upsertMetaValue(conn, HLC_CLOCK_META_KEY, encoded);
+}
+async function loadPersistedHlc(conn) {
+  await ensureMetaTable(conn);
+  const value = await selectMetaValue(conn, HLC_CLOCK_META_KEY);
+  if (value === null || !isWellFormedHlc(value)) return null;
+  return value;
+}
+
+// src/core/sync/origins.ts
+var REMOTE_ORIGIN_NODE_ID = "remote";
+
+// src/core/sync/row-lookup.ts
+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);
+}
+
+// src/core/sync/row-writer.ts
+var RowWriter = class {
+  constructor(pkResolver, changesTable) {
+    this.pkResolver = pkResolver;
+    this.changesTable = changesTable;
+  }
+  async findExistingRow(tx, change) {
+    if (!IDENTIFIER_RE.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 versioned = await selectMaxColumnVersionHlcForRow(tx, table, rowId);
+    const logged = await selectMaxRowChangeHlc(tx, this.changesTable, table, rowId);
+    if (versioned === null) return logged;
+    if (logged === null) return versioned;
+    return HLC.compare(logged, versioned) > 0 ? logged : versioned;
+  }
+  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 prepareDeleteRowColumnVersions(tx);
+      await delStmt.run(change.table, change.rowId);
+      return;
+    }
+    if (!data) return;
+    const upsertStmt = await prepareUpsertColumnVersion(tx);
+    for (const col of Object.keys(data)) {
+      if (!validateIdentifier(col)) continue;
+      await upsertStmt.run(change.table, change.rowId, col, change.hlc, change.nodeId);
+    }
+  }
+};
+
+// src/core/sync/batch-applier.ts
+var BatchApplier = class {
+  constructor(conn, localNodeId, hlc, pkResolver, getLastAppliedSeq, tracker, changesTable = CHANGES_TABLE, beforeApply) {
+    this.conn = conn;
+    this.localNodeId = localNodeId;
+    this.hlc = hlc;
+    this.getLastAppliedSeq = getLastAppliedSeq;
+    this.tracker = tracker;
+    this.changesTable = changesTable;
+    this.beforeApply = beforeApply;
+    this.rows = new RowWriter(pkResolver, changesTable);
+  }
+  rows;
+  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_RE.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 = await selectAppliedSourceSeqsInRange(this.conn, batch.sourceNodeId, batch.fromSeq, batch.toSeq);
+    }
+    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 result = await this.applyGroup({
+        sourceNodeId: batch.sourceNodeId,
+        txId,
+        changes: txChanges,
+        resolver
+      });
+      applied += result.applied;
+      skipped += result.skipped;
+      conflicts += result.conflicts;
+      droppedTables.push(...result.droppedTables);
+    }
+    const recordStmt = await prepareInsertAppliedChange(this.conn);
+    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);
+    }
+    await this.mergeHlc(batch.hlcRange.max);
+    return { applied, skipped, conflicts, droppedTables };
+  }
+  async applyGroup(options) {
+    const { sourceNodeId, txId, changes, resolver, withinTx } = options;
+    const droppedTables = [];
+    const result = await this.conn.transaction(async (tx) => {
+      const seqBefore = await this.selectMaxChangeSeq(tx);
+      if (this.beforeApply) {
+        await this.beforeApply(tx);
+      }
+      let applied = 0;
+      let skipped = 0;
+      let conflicts = 0;
+      const ddlChanges = changes.filter((c) => c.operation === "ddl");
+      const dataChanges = changes.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) {
+          droppedTables.push(droppedTable);
+        }
+        if (this.tracker) {
+          await this.tracker.refreshAllTriggersUsingConnection(tx);
+        }
+        applied += 1;
+      }
+      const tally = { applied, skipped, conflicts };
+      for (const change of dataChanges) {
+        await this.applyDataChange(tx, change, resolver, tally);
+      }
+      applied = tally.applied;
+      skipped = tally.skipped;
+      conflicts = tally.conflicts;
+      await this.stampAppliedEcho(tx, seqBefore, sourceNodeId, txId, changes);
+      if (withinTx) {
+        await withinTx(tx);
+      }
+      return { applied, skipped, conflicts };
+    });
+    return { ...result, droppedTables };
+  }
+  /**
+   * Applies one pulled transaction whose changes are read from disk in
+   * batches so that a transaction of any size is applied with bounded memory.
+   * The whole group runs in one local transaction: the batches, the echo
+   * stamping, and `withinTx` commit together or not at all.
+   */
+  async applyStagedGroup(options) {
+    const { source, resolver, withinTx } = options;
+    return this.conn.transaction(async (tx) => {
+      const seqBefore = await this.selectMaxChangeSeq(tx);
+      if (this.beforeApply) {
+        await this.beforeApply(tx);
+      }
+      const tally = { applied: 0, skipped: 0, conflicts: 0 };
+      let cursor = 0n;
+      let lastSeq = null;
+      let txId = "";
+      let sawFirst = false;
+      let sourceNodeId = REMOTE_ORIGIN_NODE_ID;
+      let maxHlc = "";
+      while (true) {
+        const batch = await source.nextBatch(cursor);
+        if (batch.length === 0) break;
+        for (const entry of batch) {
+          const change = entry.change;
+          if (change.operation === "ddl") {
+            throw new BatchValidationError("A staged device transaction cannot carry a DDL change");
+          }
+          if (!IDENTIFIER_RE.test(change.table)) {
+            throw new BatchValidationError(`Invalid table name: ${change.table}`);
+          }
+          if (!sawFirst) {
+            txId = change.txId;
+            sawFirst = true;
+          } else if (change.txId !== txId) {
+            throw new BatchValidationError(`Staged rows span more than one transaction: '${txId}' and '${change.txId}'`);
+          }
+          if (sourceNodeId === REMOTE_ORIGIN_NODE_ID && change.nodeId !== "") {
+            sourceNodeId = change.nodeId;
+          }
+          if (change.hlc > maxHlc) {
+            maxHlc = change.hlc;
+          }
+          await this.applyDataChange(tx, change, resolver, tally);
+          cursor = entry.seq;
+          lastSeq = entry.seq;
+        }
+      }
+      await this.stampAppliedEchoStamps(tx, seqBefore, sourceNodeId, txId, maxHlc);
+      if (withinTx) {
+        await withinTx(tx);
+      }
+      return { ...tally, droppedTables: [], maxHlc, lastSeq };
+    });
+  }
+  async applyDataChange(tx, change, resolver, tally) {
+    const existingRow = await this.rows.findExistingRow(tx, change);
+    if (existingRow === void 0) {
+      if (change.operation === "insert" && change.newData) {
+        await this.rows.insertRow(tx, change);
+        await this.rows.recordColumnVersions(tx, change, change.newData);
+        tally.applied += 1;
+      } else if (change.operation === "delete") {
+        tally.applied += 1;
+      } else {
+        tally.skipped += 1;
+      }
+      return;
+    }
+    tally.conflicts += 1;
+    const localHlc = await this.rows.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.rows.applyRemoteChange(tx, change);
+      await this.rows.recordColumnVersions(tx, change, change.newData);
+      tally.applied += 1;
+    } else if (resolution.action === "merge" && resolution.mergedData) {
+      await this.rows.applyMergedData(tx, change, resolution.mergedData);
+      await this.rows.recordColumnVersions(tx, change, resolution.mergedData);
+      tally.applied += 1;
+    } else {
+      tally.skipped += 1;
+    }
+  }
+  async mergeHlc(remoteHlc) {
+    try {
+      const merged = this.hlc.receive(remoteHlc);
+      await persistHlcClock(this.conn, merged);
+    } catch {
+      return;
+    }
+  }
+  async selectMaxChangeSeq(tx) {
+    return (await selectMaxChangeSeq(tx, this.changesTable)).toString();
+  }
+  async stampAppliedEcho(tx, seqBefore, sourceNodeId, txId, txChanges) {
+    let maxHlc = "";
+    for (const change of txChanges) {
+      if (change.hlc > maxHlc) {
+        maxHlc = change.hlc;
+      }
+    }
+    await this.stampAppliedEchoStamps(tx, seqBefore, sourceNodeId, txId, maxHlc);
+  }
+  async stampAppliedEchoStamps(tx, seqBefore, sourceNodeId, txId, maxHlc) {
+    const stmt = await tx.prepare(updateChangeStampsAfterSeqSql(this.changesTable));
+    await stmt.run(sourceNodeId, txId, maxHlc, seqBefore);
+  }
+};
+
+// src/core/sync/batch-reader.ts
+var BatchReader = class {
+  constructor(conn, localNodeId, changesTable, pkResolver, excludeDdl = false) {
+    this.conn = conn;
+    this.localNodeId = localNodeId;
+    this.changesTable = changesTable;
+    this.pkResolver = pkResolver;
+    this.excludeDdl = excludeDdl;
+  }
+  async readBatch(afterSeq, batchSize) {
+    const stmt = await this.conn.prepare(selectOutboundChangesSql(this.changesTable, this.excludeDdl));
+    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
+    };
+  }
+};
+
+// src/core/sync/stamp-ops.ts
+async function recordLocalColumnVersions(tx, changesTable, localNodeId, afterSeq) {
+  const selectStmt = await tx.prepare(selectNodeChangesAfterSeqSql(changesTable));
+  const rows = await selectStmt.all(afterSeq.toString(), localNodeId);
+  for (const row of rows) {
+    if (row.operation === "DELETE") {
+      const delStmt = await prepareDeleteRowColumnVersionsUpToHlc(tx);
+      await delStmt.run(row.table_name, String(row.row_id), row.hlc);
+      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 prepareUpsertNewerColumnVersion(tx);
+    for (const col of changedCols) {
+      await upsertStmt.run(row.table_name, String(row.row_id), col, row.hlc, row.node_id);
+    }
+  }
+}
+var StampOps = class {
+  constructor(localNodeId, hlc, changesTable) {
+    this.localNodeId = localNodeId;
+    this.hlc = hlc;
+    this.changesTable = changesTable;
+  }
+  async stampChanges(tx, afterSeq, txId) {
+    const hlcValue = this.hlc.now();
+    const stmt = await tx.prepare(updateChangeStampsAfterSeqSql(this.changesTable));
+    await stmt.run(this.localNodeId, txId, hlcValue, afterSeq.toString());
+    await upsertMetaValue(tx, HLC_CLOCK_META_KEY, hlcValue);
+  }
+  updateColumnVersions(tx, afterSeq) {
+    return recordLocalColumnVersions(tx, this.changesTable, this.localNodeId, afterSeq);
+  }
+};
+
+export { BatchApplier, BatchReader, HLC, HLC_CLOCK_META_KEY, LWWResolver, REMOTE_ORIGIN_NODE_ID, StampOps, Transaction, isWellFormedHlc, loadPersistedHlc, recordLocalColumnVersions };