@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/chunk-NVQS53NT.mjs

@@ -0,0 +1,665 @@
+import { META_TABLE, CHANGES_TABLE, APPLIED_CHANGES_TABLE, MIGRATIONS_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE } from './chunk-D7LAYTKN.mjs';
+import { sha256Hex } from './chunk-GVCNMPOS.mjs';
+import { SirannonError } from './chunk-UC3SCMIN.mjs';
+
+// src/core/system-catalog/applied-changes-table.ts
+function toSeq(value) {
+  if (value === null || value === void 0) return 0n;
+  return typeof value === "bigint" ? value : BigInt(String(value));
+}
+async function ensureAppliedChangesTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${APPLIED_CHANGES_TABLE}" (
+  source_node_id TEXT NOT NULL,
+  source_seq INTEGER NOT NULL,
+  applied_at REAL NOT NULL,
+  PRIMARY KEY (source_node_id, source_seq)
+)`);
+}
+function prepareInsertAppliedChange(conn) {
+  return conn.prepare(
+    `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
+  );
+}
+async function selectMaxAppliedSourceSeq(conn, sourceNodeId) {
+  const stmt = await conn.prepare(
+    `SELECT MAX(source_seq) AS max_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ?`
+  );
+  const row = await stmt.get(sourceNodeId);
+  return toSeq(row?.max_seq);
+}
+async function selectMaxAppliedSourceSeqByNode(conn) {
+  const stmt = await conn.prepare(
+    `SELECT source_node_id, MAX(source_seq) AS max_seq FROM ${APPLIED_CHANGES_TABLE} GROUP BY source_node_id`
+  );
+  const rows = await stmt.all();
+  const byNode = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.max_seq === null || row.max_seq === void 0) continue;
+    byNode.set(row.source_node_id, toSeq(row.max_seq));
+  }
+  return byNode;
+}
+async function selectAppliedSourceSeqsInRange(conn, sourceNodeId, fromSeq, toSeqBound) {
+  const stmt = await conn.prepare(
+    `SELECT source_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ? AND source_seq >= ? AND source_seq <= ?`
+  );
+  const rows = await stmt.all(sourceNodeId, fromSeq.toString(), toSeqBound.toString());
+  const seqs = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    seqs.add(String(row.source_seq));
+  }
+  return seqs;
+}
+
+// src/core/system-catalog/sqlite-catalog.ts
+async function selectTableExists(conn, table) {
+  const stmt = await conn.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?");
+  return Boolean(await stmt.get(table));
+}
+async function tableInfoRows(conn, table) {
+  const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
+  return await stmt.all();
+}
+async function tableColumnNames(conn, table) {
+  return (await tableInfoRows(conn, table)).map((col) => col.name);
+}
+async function tablePkColumns(conn, table) {
+  return (await tableInfoRows(conn, table)).filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
+}
+async function selectTableSql(conn, table) {
+  const stmt = await conn.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?");
+  const row = await stmt.get(table);
+  return row?.sql ?? null;
+}
+async function selectCountTableRows(conn, table) {
+  const stmt = await conn.prepare(`SELECT COUNT(*) AS cnt FROM "${table}"`);
+  const row = await stmt.get();
+  return Number(row?.cnt ?? 0);
+}
+async function referencedTables(conn, table) {
+  const stmt = await conn.prepare(`PRAGMA foreign_key_list("${table}")`);
+  const rows = await stmt.all();
+  return rows.map((row) => row.table);
+}
+async function setForeignKeysEnabled(conn, enabled) {
+  await conn.exec(enabled ? "PRAGMA foreign_keys = ON" : "PRAGMA foreign_keys = OFF");
+}
+async function selectUserSchemaObjects(conn, excludePrefix) {
+  const stmt = await conn.prepare(
+    `SELECT type, name, tbl_name, sql FROM sqlite_master
+     WHERE type IN ('table', 'index') AND name NOT LIKE ? AND name NOT LIKE 'sqlite_%' AND sql IS NOT NULL`
+  );
+  return await stmt.all(`${excludePrefix}%`);
+}
+async function selectUserTableNames(conn, excludePrefix) {
+  const stmt = await conn.prepare(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE ? AND name NOT LIKE 'sqlite_%'"
+  );
+  const rows = await stmt.all(`${excludePrefix}%`);
+  return rows.map((row) => row.name);
+}
+
+// src/core/system-catalog/columns.ts
+var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var SAFE_COLUMN_TYPE = /^[A-Za-z]+$/;
+var SAFE_DEFAULT_TEXT = /^[A-Za-z0-9_]*$/;
+function assertSafeIdentifier(value) {
+  if (!SAFE_IDENTIFIER.test(value)) {
+    throw new SirannonError(`Unsafe SQL identifier for internal schema: ${value}`, "INTERNAL_SCHEMA_ERROR");
+  }
+}
+async function tableColumns(conn, table) {
+  assertSafeIdentifier(table);
+  return new Set(await tableColumnNames(conn, table));
+}
+async function ensureColumn(conn, table, column, columnType, notNullDefaultText) {
+  assertSafeIdentifier(table);
+  assertSafeIdentifier(column);
+  if (!SAFE_COLUMN_TYPE.test(columnType)) {
+    throw new SirannonError(`Unsafe column type for internal schema: ${columnType}`, "INTERNAL_SCHEMA_ERROR");
+  }
+  if (notNullDefaultText !== void 0 && !SAFE_DEFAULT_TEXT.test(notNullDefaultText)) {
+    throw new SirannonError(`Unsafe column default for internal schema: ${notNullDefaultText}`, "INTERNAL_SCHEMA_ERROR");
+  }
+  if ((await tableColumns(conn, table)).has(column)) {
+    return;
+  }
+  const constraint = notNullDefaultText === void 0 ? "" : ` NOT NULL DEFAULT '${notNullDefaultText}'`;
+  try {
+    await conn.exec(`ALTER TABLE "${table}" ADD COLUMN "${column}" ${columnType}${constraint}`);
+  } catch (err) {
+    if ((await tableColumns(conn, table)).has(column)) {
+      return;
+    }
+    throw err;
+  }
+}
+
+// src/core/system-catalog/meta-table.ts
+async function ensureMetaTable(conn) {
+  await conn.exec(`CREATE TABLE IF NOT EXISTS "${META_TABLE}" (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+}
+async function selectMetaValue(conn, key) {
+  const stmt = await conn.prepare(`SELECT value FROM "${META_TABLE}" WHERE key = ?`);
+  const row = await stmt.get(key);
+  const value = row?.value;
+  return typeof value === "string" ? value : null;
+}
+async function insertMetaValueIfAbsent(conn, key, value) {
+  const stmt = await conn.prepare(`INSERT OR IGNORE INTO "${META_TABLE}" (key, value) VALUES (?, ?)`);
+  await stmt.run(key, value);
+}
+async function deleteMetaValue(conn, key) {
+  const stmt = await conn.prepare(`DELETE FROM "${META_TABLE}" WHERE key = ?`);
+  await stmt.run(key);
+}
+var UPSERT_META_VALUE_SQL = `INSERT INTO "${META_TABLE}" (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+async function upsertMetaValue(conn, key, value) {
+  const stmt = await conn.prepare(UPSERT_META_VALUE_SQL);
+  await stmt.run(key, value);
+}
+
+// src/core/system-catalog/changes-table.ts
+var CHANGE_LOG_COLUMNS = "seq, table_name, operation, row_id, changed_at, old_data, new_data, node_id, tx_id, hlc";
+var DDL_CHANGE_ROW_TABLE = "__ddl__";
+function selectChangesAfterSeqSql(tableName) {
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}" WHERE seq > ? ORDER BY seq ASC LIMIT ?`;
+}
+function selectTableChangesInRangeSql(tableName) {
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
+          WHERE table_name = ? AND seq > ? AND seq <= ?
+          ORDER BY seq ASC LIMIT ?`;
+}
+function selectTablesChangesInRangeSql(tableName, tableCount) {
+  const placeholders = Array.from({ length: tableCount }, () => "?").join(", ");
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
+          WHERE table_name IN (${placeholders}) AND seq > ? AND seq <= ?
+          ORDER BY seq ASC LIMIT ?`;
+}
+function selectNodeChangesAfterSeqSql(tableName) {
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
+          WHERE seq > ? AND node_id = ?
+          ORDER BY seq ASC`;
+}
+function selectOutboundChangesSql(tableName, excludeDdl) {
+  const ddlFilter = excludeDdl ? "AND operation != 'DDL'" : "";
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
+          WHERE seq > ? AND node_id = ? ${ddlFilter}
+          ORDER BY seq ASC LIMIT ?`;
+}
+async function selectCountOutboundChanges(conn, tableName, afterSeq, nodeId) {
+  const stmt = await conn.prepare(
+    `SELECT COUNT(*) AS pending FROM "${tableName}" WHERE seq > ? AND node_id = ? AND operation != 'DDL'`
+  );
+  const row = await stmt.get(afterSeq.toString(), nodeId);
+  return Number(row.pending);
+}
+async function insertDdlChange(conn, tableName, entry) {
+  const stmt = await conn.prepare(
+    `INSERT INTO "${tableName}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
+     VALUES ('${DDL_CHANGE_ROW_TABLE}', 'DDL', '', ?, ?, ?, ?)`
+  );
+  await stmt.run(JSON.stringify({ ddlStatement: entry.ddlStatement }), entry.nodeId, entry.txId, entry.hlc);
+}
+function updateChangeStampsAfterSeqSql(tableName) {
+  return `UPDATE "${tableName}" SET node_id = ?, tx_id = ?, hlc = ? WHERE seq > ? AND node_id = ''`;
+}
+function updateUnstampedChangeStampsSql(tableName) {
+  return `UPDATE "${tableName}" SET node_id = ?, tx_id = ?, hlc = ? WHERE node_id = ''`;
+}
+function selectMinChangeSeqSql(tableName) {
+  return `SELECT MIN(seq) AS seq FROM "${tableName}"`;
+}
+function selectMinForeignChangeSeqSql(tableName) {
+  return `SELECT MIN(seq) AS seq FROM "${tableName}" WHERE seq > ? AND node_id != ?`;
+}
+function deleteChangesBeforeSql(tableName) {
+  return `DELETE FROM "${tableName}" WHERE changed_at < ?`;
+}
+function deleteChangesBeforeUpToSeqSql(tableName) {
+  return `DELETE FROM "${tableName}" WHERE changed_at < ? AND seq <= ?`;
+}
+async function selectMaxRowChangeHlc(conn, tableName, rowTable, rowId) {
+  const stmt = await conn.prepare(
+    `SELECT MAX(hlc) AS max_hlc FROM "${tableName}" WHERE table_name = ? AND row_id = ? AND hlc != ''`
+  );
+  const row = await stmt.get(rowTable, rowId);
+  return row?.max_hlc ?? null;
+}
+async function selectMaxChangeSeq(conn, tableName = CHANGES_TABLE) {
+  const stmt = await conn.prepare(`SELECT COALESCE(MAX(seq), 0) AS seq FROM "${tableName}"`);
+  const row = await stmt.get();
+  const seq = row?.seq;
+  if (seq === void 0 || seq === null) return 0n;
+  return typeof seq === "bigint" ? seq : BigInt(String(seq));
+}
+async function selectMaxChangeHlc(conn, tableName = CHANGES_TABLE) {
+  const stmt = await conn.prepare(`SELECT MAX(hlc) AS hlc FROM "${tableName}" WHERE hlc != ''`);
+  const row = await stmt.get();
+  return typeof row?.hlc === "string" && row.hlc.length > 0 ? row.hlc : null;
+}
+async function ensureChangesTable(conn, tableName) {
+  assertSafeIdentifier(tableName);
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${tableName}" (
+  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 ensureColumn(conn, tableName, "node_id", "TEXT", "");
+  await ensureColumn(conn, tableName, "tx_id", "TEXT", "");
+  await ensureColumn(conn, tableName, "hlc", "TEXT", "");
+  await conn.exec(`CREATE INDEX IF NOT EXISTS "idx_${tableName}_changed_at" ON "${tableName}" (changed_at)`);
+  await conn.exec(`CREATE INDEX IF NOT EXISTS "idx_${tableName}_node_id" ON "${tableName}" (node_id)`);
+  await conn.exec(`CREATE INDEX IF NOT EXISTS "idx_${tableName}_hlc" ON "${tableName}" (hlc)`);
+  await ensureMetaTable(conn);
+}
+
+// src/core/system-catalog/migrations-table.ts
+var CREATE_MIGRATIONS_TABLE = `
+  CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+    version INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    applied_at REAL NOT NULL DEFAULT (unixepoch('subsec')),
+    checksum TEXT
+  )
+`;
+async function ensureMigrationsTable(conn) {
+  await conn.exec(CREATE_MIGRATIONS_TABLE);
+  await ensureColumn(conn, MIGRATIONS_TABLE, "checksum", "TEXT");
+}
+async function selectAppliedMigrations(conn) {
+  const stmt = await conn.prepare(`SELECT version, name, checksum FROM ${MIGRATIONS_TABLE} ORDER BY version`);
+  return await stmt.all();
+}
+async function replaceMigrationHistory(conn, rows) {
+  await ensureMigrationsTable(conn);
+  await conn.transaction(async (tx) => {
+    await tx.exec(`DELETE FROM ${MIGRATIONS_TABLE}`);
+    const insert = await tx.prepare(`INSERT INTO ${MIGRATIONS_TABLE} (version, name, checksum) VALUES (?, ?, ?)`);
+    for (const row of rows) {
+      await insert.run(row.version, row.name, row.checksum);
+    }
+  });
+}
+async function selectAppliedMigrationsNewestFirst(conn) {
+  const stmt = await conn.prepare(`SELECT version, name FROM ${MIGRATIONS_TABLE} ORDER BY version DESC`);
+  return await stmt.all();
+}
+function prepareInsertMigration(conn) {
+  return conn.prepare(`INSERT INTO ${MIGRATIONS_TABLE} (version, name, checksum) VALUES (?, ?, ?)`);
+}
+function prepareUpdateMigrationChecksum(conn) {
+  return conn.prepare(`UPDATE ${MIGRATIONS_TABLE} SET checksum = ? WHERE version = ?`);
+}
+function prepareDeleteMigration(conn) {
+  return conn.prepare(`DELETE FROM ${MIGRATIONS_TABLE} WHERE version = ?`);
+}
+function highestMigrationVersion(rows) {
+  let highest = 0;
+  for (const row of rows) {
+    if (row.version > highest) highest = row.version;
+  }
+  return highest;
+}
+
+// src/core/system-catalog/column-versions-table.ts
+var UPSERT_COLUMN_VERSION = `INSERT INTO ${COLUMN_VERSIONS_TABLE} (table_name, row_id, column_name, hlc, node_id)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(table_name, row_id, column_name)
+       DO UPDATE SET hlc = excluded.hlc, node_id = excluded.node_id`;
+async function ensureColumnVersionsTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${COLUMN_VERSIONS_TABLE}" (
+  table_name TEXT NOT NULL,
+  row_id TEXT NOT NULL,
+  column_name TEXT NOT NULL,
+  hlc TEXT NOT NULL,
+  node_id TEXT NOT NULL,
+  PRIMARY KEY (table_name, row_id, column_name)
+)`);
+}
+async function selectMaxColumnVersionHlc(conn) {
+  const stmt = await conn.prepare(`SELECT MAX(hlc) AS max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE hlc != ''`);
+  const row = await stmt.get();
+  return row?.max_hlc ?? null;
+}
+async function selectMaxColumnVersionHlcForRow(conn, tableName, rowId) {
+  const stmt = await conn.prepare(
+    `SELECT MAX(hlc) AS max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`
+  );
+  const row = await stmt.get(tableName, rowId);
+  return row?.max_hlc ?? null;
+}
+function prepareUpsertColumnVersion(conn) {
+  return conn.prepare(UPSERT_COLUMN_VERSION);
+}
+function prepareUpsertNewerColumnVersion(conn) {
+  return conn.prepare(`${UPSERT_COLUMN_VERSION}
+       WHERE excluded.hlc > ${COLUMN_VERSIONS_TABLE}.hlc`);
+}
+function prepareDeleteRowColumnVersions(conn) {
+  return conn.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`);
+}
+function prepareDeleteRowColumnVersionsUpToHlc(conn) {
+  return conn.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ? AND hlc <= ?`);
+}
+
+// src/core/system-catalog/device-cursors-table.ts
+async function ensureDeviceCursorsTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${DEVICE_CURSORS_TABLE}" (
+  device_id TEXT PRIMARY KEY,
+  acked_seq INTEGER NOT NULL DEFAULT 0,
+  updated_at REAL NOT NULL
+)`);
+}
+async function upsertDeviceCursor(conn, deviceId, ackedSeq, updatedAt) {
+  const stmt = await conn.prepare(
+    `INSERT INTO "${DEVICE_CURSORS_TABLE}" (device_id, acked_seq, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(device_id) DO UPDATE SET
+       acked_seq = max("${DEVICE_CURSORS_TABLE}".acked_seq, excluded.acked_seq),
+       updated_at = excluded.updated_at`
+  );
+  await stmt.run(deviceId, ackedSeq.toString(), updatedAt);
+}
+async function deleteDeviceCursorsUpdatedBefore(conn, cutoff) {
+  const stmt = await conn.prepare(`DELETE FROM "${DEVICE_CURSORS_TABLE}" WHERE updated_at < ?`);
+  const result = await stmt.run(cutoff);
+  return result.changes;
+}
+async function selectDeviceCursors(conn) {
+  const stmt = await conn.prepare(`SELECT device_id, acked_seq FROM "${DEVICE_CURSORS_TABLE}"`);
+  const rows = await stmt.all();
+  return rows.map((row) => ({ deviceId: row.device_id, ackedSeq: BigInt(row.acked_seq) }));
+}
+
+// src/core/system-catalog/peer-state-table.ts
+async function ensurePeerStateTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${PEER_STATE_TABLE}" (
+  peer_node_id TEXT PRIMARY KEY,
+  last_acked_seq INTEGER NOT NULL DEFAULT 0,
+  last_received_hlc TEXT NOT NULL DEFAULT '',
+  updated_at REAL NOT NULL
+)`);
+}
+async function upsertPeerAckedSeq(conn, peerNodeId, seq, updatedAt) {
+  const stmt = await conn.prepare(
+    `INSERT INTO ${PEER_STATE_TABLE} (peer_node_id, last_acked_seq, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(peer_node_id)
+     DO UPDATE SET
+       last_acked_seq = max(${PEER_STATE_TABLE}.last_acked_seq, excluded.last_acked_seq),
+       updated_at = CASE
+         WHEN excluded.last_acked_seq >= ${PEER_STATE_TABLE}.last_acked_seq THEN excluded.updated_at
+         ELSE ${PEER_STATE_TABLE}.updated_at
+       END`
+  );
+  await stmt.run(peerNodeId, seq.toString(), updatedAt);
+}
+async function selectPeerAckedSeq(conn, peerNodeId) {
+  const stmt = await conn.prepare(`SELECT last_acked_seq FROM ${PEER_STATE_TABLE} WHERE peer_node_id = ?`);
+  const row = await stmt.get(peerNodeId);
+  const seq = row?.last_acked_seq;
+  if (seq === null || seq === void 0) return 0n;
+  return typeof seq === "bigint" ? seq : BigInt(String(seq));
+}
+async function selectMinPeerAckedSeq(conn) {
+  const stmt = await conn.prepare(`SELECT MIN(last_acked_seq) AS min_seq, COUNT(*) AS cnt FROM ${PEER_STATE_TABLE}`);
+  const row = await stmt.get();
+  if (row === void 0 || Number(row.cnt ?? 0) === 0) return null;
+  const min = row.min_seq;
+  if (min === null || min === void 0) return 0n;
+  return typeof min === "bigint" ? min : BigInt(String(min));
+}
+
+// src/core/system-catalog/sync-state-table.ts
+var SYNC_META_ROW = "__sync_meta__";
+async function ensureSyncStateTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${SYNC_STATE_TABLE}" (
+  table_name TEXT PRIMARY KEY,
+  status TEXT NOT NULL DEFAULT 'pending',
+  row_count INTEGER NOT NULL DEFAULT 0,
+  pk_hash TEXT NOT NULL DEFAULT '',
+  snapshot_seq INTEGER,
+  source_peer_id TEXT,
+  started_at REAL,
+  completed_at REAL,
+  request_id TEXT
+)`);
+}
+async function upsertSyncTableStatus(conn, entry) {
+  const stmt = await conn.prepare(
+    `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, row_count, pk_hash, completed_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(table_name) DO UPDATE SET
+       status = excluded.status,
+       row_count = COALESCE(excluded.row_count, row_count),
+       pk_hash = COALESCE(excluded.pk_hash, pk_hash),
+       completed_at = excluded.completed_at`
+  );
+  await stmt.run(entry.tableName, entry.status, entry.rowCount, entry.pkHash, entry.completedAt);
+}
+async function upsertSyncMeta(conn, entry) {
+  const stmt = await conn.prepare(
+    `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, snapshot_seq, source_peer_id, started_at, request_id)
+     VALUES ('${SYNC_META_ROW}', ?, ?, ?, ?, ?)
+     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(
+    entry.status,
+    entry.snapshotSeq !== void 0 ? entry.snapshotSeq.toString() : null,
+    entry.sourcePeerId ?? null,
+    entry.startedAt,
+    entry.requestId ?? null
+  );
+}
+async function selectSyncMetaRow(conn) {
+  const stmt = await conn.prepare(
+    `SELECT status, snapshot_seq, source_peer_id FROM ${SYNC_STATE_TABLE} WHERE table_name = '${SYNC_META_ROW}'`
+  );
+  const row = await stmt.get();
+  if (!row) return null;
+  const seq = row.snapshot_seq;
+  return {
+    status: row.status,
+    snapshotSeq: seq === null || seq === void 0 ? null : typeof seq === "bigint" ? seq : BigInt(String(seq)),
+    sourcePeerId: row.source_peer_id
+  };
+}
+async function selectCompletedSyncTableNames(conn) {
+  const stmt = await conn.prepare(
+    `SELECT table_name FROM ${SYNC_STATE_TABLE} WHERE table_name != '${SYNC_META_ROW}' AND status = 'completed'`
+  );
+  const rows = await stmt.all();
+  return rows.map((row) => row.table_name);
+}
+async function deleteSyncTableStates(conn) {
+  await conn.exec(`DELETE FROM ${SYNC_STATE_TABLE} WHERE table_name != '${SYNC_META_ROW}'`);
+}
+
+// src/core/system-catalog/replication-tables.ts
+async function ensureBatchApplyTables(conn) {
+  await ensureAppliedChangesTable(conn);
+  await ensureColumnVersionsTable(conn);
+}
+async function ensureReplicationStateTables(conn) {
+  await ensurePeerStateTable(conn);
+  await ensureBatchApplyTables(conn);
+  await ensureSyncStateTable(conn);
+}
+
+// src/core/system-catalog/staged-changes-table.ts
+function toSeq2(value) {
+  if (value === null || value === void 0) return null;
+  return typeof value === "bigint" ? value : BigInt(String(value));
+}
+var STAGED_COLUMNS = "seq, table_name, operation, row_id, changed_at, old_data, new_data, node_id, tx_id, hlc, tx_end";
+async function ensureStagedChangesTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${STAGED_CHANGES_TABLE}" (
+  seq INTEGER PRIMARY KEY,
+  table_name TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  row_id TEXT NOT NULL,
+  changed_at REAL NOT NULL,
+  old_data TEXT,
+  new_data TEXT,
+  node_id TEXT NOT NULL DEFAULT '',
+  tx_id TEXT NOT NULL DEFAULT '',
+  hlc TEXT NOT NULL DEFAULT '',
+  tx_end INTEGER NOT NULL DEFAULT 0
+)`);
+  await conn.exec(
+    `CREATE INDEX IF NOT EXISTS "idx_${STAGED_CHANGES_TABLE}_tx_end" ON "${STAGED_CHANGES_TABLE}" (tx_end, seq)`
+  );
+}
+function upsertStagedChangeSql() {
+  return `INSERT INTO "${STAGED_CHANGES_TABLE}" (${STAGED_COLUMNS})
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(seq) DO UPDATE SET
+            table_name = excluded.table_name,
+            operation = excluded.operation,
+            row_id = excluded.row_id,
+            changed_at = excluded.changed_at,
+            old_data = excluded.old_data,
+            new_data = excluded.new_data,
+            node_id = excluded.node_id,
+            tx_id = excluded.tx_id,
+            hlc = excluded.hlc,
+            tx_end = excluded.tx_end`;
+}
+async function selectMaxStagedSeq(conn) {
+  const stmt = await conn.prepare(`SELECT MAX(seq) AS seq FROM "${STAGED_CHANGES_TABLE}"`);
+  const row = await stmt.get();
+  return toSeq2(row?.seq);
+}
+async function selectFirstStagedTransactionEnd(conn) {
+  const stmt = await conn.prepare(
+    `SELECT seq, tx_id FROM "${STAGED_CHANGES_TABLE}" WHERE tx_end = 1 ORDER BY seq ASC LIMIT 1`
+  );
+  const row = await stmt.get();
+  const seq = toSeq2(row?.seq);
+  if (seq === null) return null;
+  return { seq, txId: row?.tx_id ?? "" };
+}
+async function selectStagedChangesInRange(conn, afterSeq, upToSeq, limit) {
+  const stmt = await conn.prepare(
+    `SELECT ${STAGED_COLUMNS} FROM "${STAGED_CHANGES_TABLE}"
+     WHERE seq > ? AND seq <= ? ORDER BY seq ASC LIMIT ?`
+  );
+  return await stmt.all(afterSeq.toString(), upToSeq.toString(), limit);
+}
+async function deleteStagedChangesUpToSeq(conn, upToSeq) {
+  const stmt = await conn.prepare(`DELETE FROM "${STAGED_CHANGES_TABLE}" WHERE seq <= ?`);
+  await stmt.run(upToSeq.toString());
+}
+async function deleteAllStagedChanges(conn) {
+  await conn.exec(`DELETE FROM "${STAGED_CHANGES_TABLE}"`);
+}
+
+// src/core/sync/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/core/sync/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 pkCols = await this.forTableOnConnection(this.conn, table);
+    this.cache.set(table, pkCols);
+    return pkCols;
+  }
+  async forTableOnConnection(conn, table) {
+    const pkCols = await tablePkColumns(conn, table);
+    if (pkCols.length === 0) {
+      pkCols.push("rowid");
+    }
+    return pkCols;
+  }
+};
+
+// src/core/sync/checksum.ts
+function computeChecksum(changes) {
+  return sha256Hex(canonicaliseForChecksum(changes));
+}
+
+// src/core/sync/validators.ts
+var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var SEQ_STRING_RE = /^\d{1,19}$/;
+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_RE = /\b(load_extension|ATTACH|randomblob|zeroblob|writefile|readfile|fts3_tokenizer)\b/i;
+function validateIdentifier(name) {
+  return IDENTIFIER_RE.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_RE.test(sql)) return false;
+  const body = sql.replace(SAFE_DDL_RE, "");
+  if (/\bSELECT\b/i.test(body)) return false;
+  return true;
+}
+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;
+}
+
+export { IDENTIFIER_RE, PkResolver, SEQ_STRING_RE, UPSERT_META_VALUE_SQL, assertSafeIdentifier, canonicaliseForChecksum, computeChecksum, deleteAllStagedChanges, deleteChangesBeforeSql, deleteChangesBeforeUpToSeqSql, deleteDeviceCursorsUpdatedBefore, deleteMetaValue, deleteStagedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplicationStateTables, ensureStagedChangesTable, extractDroppedTable, highestMigrationVersion, insertDdlChange, insertMetaValueIfAbsent, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareDeleteRowColumnVersionsUpToHlc, prepareInsertAppliedChange, prepareInsertMigration, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, referencedTables, replaceMigrationHistory, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectDeviceCursors, selectFirstStagedTransactionEnd, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinForeignChangeSeqSql, selectMinPeerAckedSeq, selectNodeChangesAfterSeqSql, selectOutboundChangesSql, selectPeerAckedSeq, selectStagedChangesInRange, selectSyncMetaRow, selectTableChangesInRangeSql, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnNames, tableInfoRows, tablePkColumns, updateChangeStampsAfterSeqSql, updateUnstampedChangeStampsSql, upsertDeviceCursor, upsertMetaValue, upsertPeerAckedSeq, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };