@delali/sirannon-db 0.3.5-next.69 → 0.3.5-next.71

package/dist/{chunk-ESTZZPT5.mjs → chunk-56HOLQKD.mjs}

@@ -1,5 +1,5 @@
-import { ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { META_TABLE, CHANGES_TABLE, MIGRATIONS_TABLE, APPLIED_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-2O3PP4CF.mjs';
+import { ReplicationError, BatchValidationError } from './chunk-BLMRNSUG.mjs';
+import { CHANGES_TABLE, META_TABLE, MIGRATIONS_TABLE, REPLACED_ROWS_TABLE, APPLIED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-EUNHTFR7.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/sync/hlc.ts
@@ -89,6 +89,12 @@ var HLC = class _HLC {
 };
 
 // src/core/system-catalog/sqlite-catalog.ts
+var TABLE_XINFO_HIDDEN = {
+  ordinary: 0,
+  virtualTableColumn: 1,
+  generatedVirtual: 2,
+  generatedStored: 3
+};
 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));
@@ -97,17 +103,29 @@ async function tableInfoRows(conn, table) {
   const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
   return await stmt.all();
 }
+async function tableColumnsWithGenerated(conn, table) {
+  const stmt = await conn.prepare(`PRAGMA table_xinfo("${table}")`);
+  return (await stmt.all()).map((row) => ({ ...row, hidden: Number(row.hidden) }));
+}
 async function tableColumnNames(conn, table) {
   return (await tableInfoRows(conn, table)).map((col) => col.name);
 }
+function primaryKeyColumns(columns) {
+  return columns.filter((column) => column.pk > 0).sort((a, b) => a.pk - b.pk).map((column) => column.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);
+  return primaryKeyColumns(await tableInfoRows(conn, table));
 }
 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 selectTriggerSql(conn, trigger) {
+  const stmt = await conn.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?");
+  const row = await stmt.get(trigger);
+  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();
@@ -135,6 +153,34 @@ async function selectUserTableNames(conn, excludePrefix) {
   const rows = await stmt.all(`${excludePrefix}%`);
   return rows.map((row) => row.name);
 }
+async function selectOrdinaryTableName(conn, table) {
+  const stmt = await conn.prepare(
+    `SELECT name FROM sqlite_master
+     WHERE type = 'table' AND name = ? COLLATE NOCASE AND sql NOT LIKE 'CREATE VIRTUAL TABLE%'`
+  );
+  const row = await stmt.get(table);
+  return typeof row?.name === "string" ? row.name : null;
+}
+async function selectIndexSql(conn, index) {
+  const stmt = await conn.prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?");
+  const row = await stmt.get(index);
+  return row?.sql ?? null;
+}
+async function tableIndexList(conn, table) {
+  const stmt = await conn.prepare('SELECT name, "unique", origin, partial FROM pragma_index_list(?) ORDER BY seq');
+  const rows = await stmt.all(table);
+  return rows.map((row) => ({
+    name: row.name,
+    unique: Number(row.unique),
+    origin: row.origin,
+    partial: Number(row.partial)
+  }));
+}
+async function indexColumns(conn, index) {
+  const stmt = await conn.prepare('SELECT cid, name, coll, "key" FROM pragma_index_xinfo(?) ORDER BY seqno');
+  const rows = await stmt.all(index);
+  return rows.map((row) => ({ cid: Number(row.cid), name: row.name, collation: row.coll, key: Number(row.key) }));
+}
 
 // src/core/system-catalog/columns.ts
 var SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -192,14 +238,29 @@ async function deleteMetaValue(conn, key) {
 }
 var UPSERT_META_VALUE_SQL = `INSERT INTO "${META_TABLE}" (key, value) VALUES (?, ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+function upsertMetaMaxChangeSeqSql(changesTable) {
+  return `INSERT INTO "${META_TABLE}" (key, value)
+     VALUES (?, (SELECT CAST(COALESCE(MAX(seq), 0) AS TEXT) FROM "${changesTable}"))
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+}
+function upsertMetaValueAndMaxChangeSeqSql(changesTable) {
+  return `INSERT INTO "${META_TABLE}" (key, value)
+     VALUES (?, ?), (?, (SELECT CAST(COALESCE(MAX(seq), 0) AS TEXT) FROM "${changesTable}"))
+     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 SQLITE_SEQUENCE_TABLE = "sqlite_sequence";
 var DDL_CHANGE_ROW_TABLE = "__ddl__";
+var CHANGE_LOG_COLUMNS = "seq, table_name, operation, row_id, changed_at, old_data, new_data, node_id, tx_id, hlc";
+function seqFromColumn(value) {
+  if (value === void 0 || value === null) return 0n;
+  return typeof value === "bigint" ? value : BigInt(String(value));
+}
 function selectChangesAfterSeqSql(tableName) {
   return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}" WHERE seq > ? ORDER BY seq ASC LIMIT ?`;
 }
@@ -237,15 +298,13 @@ async function insertDdlChange(conn, tableName, entry) {
 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 updateChangeStampsAboveMetaSeqSql(tableName) {
+  return `UPDATE "${tableName}" SET node_id = ?, tx_id = ?, hlc = ?
+     WHERE node_id = '' AND seq > COALESCE((SELECT CAST(value AS INTEGER) FROM "${META_TABLE}" WHERE key = ?), 0)`;
 }
 function selectMinChangeSeqSql(tableName) {
   return `SELECT MIN(seq) AS seq FROM "${tableName}"`;
 }
-function deleteChangesBeforeSql(tableName) {
-  return `DELETE FROM "${tableName}" WHERE changed_at < ?`;
-}
 function deleteChangesBeforeUpToSeqSql(tableName) {
   return `DELETE FROM "${tableName}" WHERE changed_at < ? AND seq <= ?`;
 }
@@ -259,9 +318,20 @@ async function selectMaxRowChangeHlc(conn, tableName, rowTable, rowId) {
 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));
+  return seqFromColumn(row?.seq);
+}
+async function selectMaxAssignedChangeSeq(conn, tableName = CHANGES_TABLE) {
+  const logged = await selectMaxChangeSeq(conn, tableName);
+  if (!await selectTableExists(conn, SQLITE_SEQUENCE_TABLE)) return logged;
+  const stmt = await conn.prepare(`SELECT seq FROM ${SQLITE_SEQUENCE_TABLE} WHERE name = ?`);
+  const row = await stmt.get(tableName);
+  const assigned = seqFromColumn(row?.seq);
+  return assigned > logged ? assigned : logged;
+}
+async function selectMaxNodeChangeSeq(conn, tableName, nodeId) {
+  const stmt = await conn.prepare(`SELECT COALESCE(MAX(seq), 0) AS seq FROM "${tableName}" WHERE node_id = ?`);
+  const row = await stmt.get(nodeId);
+  return seqFromColumn(row?.seq);
 }
 async function selectMaxChangeHlc(conn, tableName = CHANGES_TABLE) {
   const stmt = await conn.prepare(`SELECT MAX(hlc) AS hlc FROM "${tableName}" WHERE hlc != ''`);
@@ -340,11 +410,31 @@ function highestMigrationVersion(rows) {
   return highest;
 }
 
-// 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));
+// src/core/system-catalog/replaced-rows-table.ts
+async function ensureReplacedRowsTable(conn) {
+  await conn.exec(
+    `CREATE TABLE IF NOT EXISTS "${REPLACED_ROWS_TABLE}" (
+      table_name TEXT NOT NULL,
+      row_key NOT NULL,
+      match_key TEXT NOT NULL,
+      row_id NOT NULL,
+      old_data TEXT,
+      UNIQUE (table_name, row_key)
+    )`
+  );
+  await conn.exec(
+    `CREATE INDEX IF NOT EXISTS "${REPLACED_ROWS_TABLE}_by_match" ON "${REPLACED_ROWS_TABLE}" (table_name, match_key)`
+  );
 }
+async function deleteReplacedRowsOfTable(conn, table) {
+  const stmt = await conn.prepare(`DELETE FROM "${REPLACED_ROWS_TABLE}" WHERE table_name = ?`);
+  await stmt.run(table);
+}
+async function deleteAllReplacedRows(conn) {
+  await conn.exec(`DELETE FROM "${REPLACED_ROWS_TABLE}"`);
+}
+
+// src/core/system-catalog/applied-changes-table.ts
 async function ensureAppliedChangesTable(conn) {
   await conn.exec(`
 CREATE TABLE IF NOT EXISTS "${APPLIED_CHANGES_TABLE}" (
@@ -359,12 +449,23 @@ function prepareInsertAppliedChange(conn) {
     `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
   );
 }
+async function insertAppliedChangesFromStagedPush(conn, sourceNodeId, appliedAt) {
+  const stmt = await conn.prepare(
+    `INSERT OR IGNORE INTO "${APPLIED_CHANGES_TABLE}" (source_node_id, source_seq, applied_at)
+     SELECT source_node_id, source_seq, ? FROM "${STAGED_PUSH_CHANGES_TABLE}" WHERE source_node_id = ?`
+  );
+  await stmt.run(appliedAt, sourceNodeId);
+}
+async function deleteAppliedChangesAfterSeq(conn, sourceNodeId, seq) {
+  const stmt = await conn.prepare(`DELETE FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ? AND source_seq > ?`);
+  await stmt.run(sourceNodeId, seq.toString());
+}
 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);
+  return seqFromColumn(row?.max_seq);
 }
 async function selectMaxAppliedSourceSeqByNode(conn) {
   const stmt = await conn.prepare(
@@ -374,7 +475,7 @@ async function selectMaxAppliedSourceSeqByNode(conn) {
   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));
+    byNode.set(row.source_node_id, seqFromColumn(row.max_seq));
   }
   return byNode;
 }
@@ -390,6 +491,73 @@ async function selectAppliedSourceSeqsInRange(conn, sourceNodeId, fromSeq, toSeq
   return seqs;
 }
 
+// src/core/system-catalog/changes-history.ts
+function originPlaceholders(originCount) {
+  return Array.from({ length: originCount }, () => "?").join(", ");
+}
+function selectOutboundHistoryChangesSql(tableName, originCount) {
+  return `SELECT ${CHANGE_LOG_COLUMNS} FROM "${tableName}"
+          WHERE seq > ? AND hlc != '' AND node_id IN (${originPlaceholders(originCount)})
+          ORDER BY seq ASC LIMIT ?`;
+}
+async function selectNewestHistoryChange(conn, tableName, origins, bounds = {}) {
+  if (origins.length === 0) return null;
+  const seqFilter = bounds.maxSeq === void 0 ? "" : "AND seq <= ?";
+  const hlcFilter = bounds.beforeHlc === void 0 ? "" : "AND hlc < ?";
+  const stmt = await conn.prepare(
+    `SELECT seq, hlc, tx_id FROM "${tableName}"
+     WHERE hlc != '' AND node_id IN (${originPlaceholders(origins.length)}) ${seqFilter} ${hlcFilter}
+     ORDER BY hlc DESC, seq DESC LIMIT 1`
+  );
+  const params = [...origins];
+  if (bounds.maxSeq !== void 0) params.push(bounds.maxSeq.toString());
+  if (bounds.beforeHlc !== void 0) params.push(bounds.beforeHlc);
+  const row = await stmt.get(...params);
+  if (!row) return null;
+  return await selectHistoryTransaction(conn, tableName, row.tx_id) ?? {
+    seq: seqFromColumn(row.seq),
+    hlc: row.hlc,
+    txId: row.tx_id
+  };
+}
+async function selectMaxHistoryChangeSeq(conn, tableName, origins) {
+  if (origins.length === 0) return 0n;
+  const stmt = await conn.prepare(
+    `SELECT COALESCE(MAX(seq), 0) AS seq FROM "${tableName}"
+     WHERE hlc != '' AND node_id IN (${originPlaceholders(origins.length)})`
+  );
+  const row = await stmt.get(...origins);
+  return seqFromColumn(row?.seq);
+}
+async function selectHistoryTransaction(conn, tableName, txId) {
+  const stmt = await conn.prepare(
+    `SELECT MAX(seq) AS seq, MAX(hlc) AS hlc FROM "${tableName}" WHERE tx_id = ? AND hlc != ''`
+  );
+  const row = await stmt.get(txId);
+  if (row?.seq === void 0 || row.seq === null || typeof row.hlc !== "string") return null;
+  return { seq: seqFromColumn(row.seq), hlc: row.hlc, txId };
+}
+async function selectHistoryChangesAfterHlc(conn, tableName, origins, hlc) {
+  if (origins.length === 0) return [];
+  const stmt = await conn.prepare(
+    `SELECT seq, table_name, operation, row_id, old_data, new_data FROM "${tableName}"
+     WHERE hlc > ? AND node_id IN (${originPlaceholders(origins.length)})
+     ORDER BY seq DESC`
+  );
+  return await stmt.all(hlc, ...origins);
+}
+async function deleteHistoryChangesAfterHlc(conn, tableName, origins, hlc) {
+  if (origins.length === 0) return;
+  const stmt = await conn.prepare(
+    `DELETE FROM "${tableName}" WHERE hlc > ? AND node_id IN (${originPlaceholders(origins.length)})`
+  );
+  await stmt.run(hlc, ...origins);
+}
+async function deleteStampedChangesUpToSeq(conn, tableName, seq) {
+  const stmt = await conn.prepare(`DELETE FROM "${tableName}" WHERE seq <= ? AND hlc != ''`);
+  await stmt.run(seq.toString());
+}
+
 // 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 (?, ?, ?, ?, ?)
@@ -418,6 +586,13 @@ async function selectMaxColumnVersionHlcForRow(conn, tableName, rowId) {
   const row = await stmt.get(tableName, rowId);
   return row?.max_hlc ?? null;
 }
+async function deleteColumnVersionsAfterHlc(conn, hlc) {
+  const stmt = await conn.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE hlc > ?`);
+  await stmt.run(hlc);
+}
+async function deleteColumnVersions(conn) {
+  await conn.exec(`DELETE FROM ${COLUMN_VERSIONS_TABLE}`);
+}
 function prepareUpsertColumnVersion(conn) {
   return conn.prepare(UPSERT_COLUMN_VERSION);
 }
@@ -428,9 +603,6 @@ function prepareUpsertNewerColumnVersion(conn) {
 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) {
@@ -451,6 +623,19 @@ async function upsertDeviceCursor(conn, deviceId, ackedSeq, updatedAt) {
   );
   await stmt.run(deviceId, ackedSeq.toString(), updatedAt);
 }
+async function updateDeviceCursor(conn, deviceId, ackedSeq, updatedAt) {
+  const stmt = await conn.prepare(
+    `UPDATE "${DEVICE_CURSORS_TABLE}"
+     SET acked_seq = max(acked_seq, CAST(? AS INTEGER)), updated_at = ?
+     WHERE device_id = ?`
+  );
+  const result = await stmt.run(ackedSeq.toString(), updatedAt, deviceId);
+  return result.changes;
+}
+async function selectDeviceCursorExists(conn, deviceId) {
+  const stmt = await conn.prepare(`SELECT 1 AS present FROM "${DEVICE_CURSORS_TABLE}" WHERE device_id = ?`);
+  return await stmt.get(deviceId) !== void 0;
+}
 async function deleteExpiredDeviceCursors(conn, changesTable, bounds) {
   assertSafeIdentifier(changesTable);
   const stmt = await conn.prepare(
@@ -521,20 +706,98 @@ async function upsertPeerAckedSeq(conn, peerNodeId, seq, updatedAt) {
   );
   await stmt.run(peerNodeId, seq.toString(), updatedAt);
 }
+async function deletePeerStates(conn) {
+  await conn.exec(`DELETE FROM ${PEER_STATE_TABLE}`);
+}
+async function deletePeerState(conn, peerNodeId) {
+  const stmt = await conn.prepare(`DELETE FROM ${PEER_STATE_TABLE} WHERE peer_node_id = ?`);
+  await stmt.run(peerNodeId);
+}
 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));
+  return seqFromColumn(row?.last_acked_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));
+  return seqFromColumn(row.min_seq);
+}
+
+// src/core/system-catalog/replication-history-meta.ts
+var PRIMARY_TERM_START_META_KEY = "replication_primary_term_start";
+var ANCHORED_TERM_META_KEY = "replication_anchored_term";
+var HISTORY_BASE_META_KEY = "replication_history_base";
+var QUARANTINED_META_KEY = "replication_quarantined";
+var DECIMAL_DIGITS = /^\d+$/;
+function parseTermStart(raw) {
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const term = Reflect.get(parsed, "term");
+    const seq = Reflect.get(parsed, "seq");
+    if (typeof term !== "string" || typeof seq !== "string") return null;
+    if (!DECIMAL_DIGITS.test(term) || !DECIMAL_DIGITS.test(seq)) return null;
+    return { term: BigInt(term), seq: BigInt(seq) };
+  } catch {
+    return null;
+  }
+}
+function parseHistoryPoint(raw) {
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const hlc = Reflect.get(parsed, "hlc");
+    const txId = Reflect.get(parsed, "txId");
+    if (typeof hlc !== "string" || typeof txId !== "string" || hlc === "") return null;
+    return { hlc, txId };
+  } catch {
+    return null;
+  }
+}
+async function selectPrimaryTermStart(conn) {
+  await ensureMetaTable(conn);
+  return parseTermStart(await selectMetaValue(conn, PRIMARY_TERM_START_META_KEY));
+}
+async function upsertPrimaryTermStart(conn, termStart) {
+  await ensureMetaTable(conn);
+  await upsertMetaValue(
+    conn,
+    PRIMARY_TERM_START_META_KEY,
+    JSON.stringify({ term: termStart.term.toString(), seq: termStart.seq.toString() })
+  );
+}
+async function deletePrimaryTermStart(conn) {
+  await ensureMetaTable(conn);
+  await deleteMetaValue(conn, PRIMARY_TERM_START_META_KEY);
+}
+async function selectAnchoredTerm(conn) {
+  await ensureMetaTable(conn);
+  const raw = await selectMetaValue(conn, ANCHORED_TERM_META_KEY);
+  return raw !== null && DECIMAL_DIGITS.test(raw) ? BigInt(raw) : null;
+}
+async function upsertAnchoredTerm(conn, term) {
+  await ensureMetaTable(conn);
+  await upsertMetaValue(conn, ANCHORED_TERM_META_KEY, term.toString());
+}
+async function selectHistoryBase(conn) {
+  await ensureMetaTable(conn);
+  return parseHistoryPoint(await selectMetaValue(conn, HISTORY_BASE_META_KEY));
+}
+async function upsertHistoryBase(conn, point) {
+  await ensureMetaTable(conn);
+  await upsertMetaValue(conn, HISTORY_BASE_META_KEY, point ? JSON.stringify({ hlc: point.hlc, txId: point.txId }) : "");
+}
+async function selectQuarantined(conn) {
+  await ensureMetaTable(conn);
+  return await selectMetaValue(conn, QUARANTINED_META_KEY) === "true";
+}
+async function upsertQuarantined(conn, quarantined) {
+  await ensureMetaTable(conn);
+  await upsertMetaValue(conn, QUARANTINED_META_KEY, quarantined ? "true" : "false");
 }
 
 // src/core/system-catalog/sync-state-table.ts
@@ -620,7 +883,7 @@ async function ensureReplicationStateTables(conn) {
 }
 
 // src/core/system-catalog/staged-changes-table.ts
-function toSeq2(value) {
+function toSeq(value) {
   if (value === null || value === void 0) return null;
   return typeof value === "bigint" ? value : BigInt(String(value));
 }
@@ -662,14 +925,14 @@ function upsertStagedChangeSql() {
 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);
+  return toSeq(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);
+  const seq = toSeq(row?.seq);
   if (seq === null) return null;
   return { seq, txId: row?.tx_id ?? "" };
 }
@@ -688,6 +951,51 @@ async function deleteAllStagedChanges(conn) {
   await conn.exec(`DELETE FROM "${STAGED_CHANGES_TABLE}"`);
 }
 
+// src/core/system-catalog/staged-push-changes-table.ts
+async function ensureStagedPushChangesTable(conn) {
+  await conn.exec(`
+CREATE TABLE IF NOT EXISTS "${STAGED_PUSH_CHANGES_TABLE}" (
+  source_node_id TEXT NOT NULL,
+  source_seq INTEGER NOT NULL,
+  tx_id TEXT NOT NULL,
+  change TEXT NOT NULL,
+  PRIMARY KEY (source_node_id, source_seq)
+)`);
+}
+function prepareInsertStagedPushChange(conn) {
+  return conn.prepare(
+    `INSERT OR IGNORE INTO "${STAGED_PUSH_CHANGES_TABLE}" (source_node_id, source_seq, tx_id, change) VALUES (?, ?, ?, ?)`
+  );
+}
+async function selectStagedPushTail(conn, sourceNodeId) {
+  const stmt = await conn.prepare(
+    `SELECT tx_id, source_seq FROM "${STAGED_PUSH_CHANGES_TABLE}"
+     WHERE source_node_id = ? ORDER BY source_seq DESC LIMIT 1`
+  );
+  const row = await stmt.get(sourceNodeId);
+  if (row === void 0 || row.source_seq === null || row.source_seq === void 0) return null;
+  return { txId: row.tx_id, maxSeq: BigInt(String(row.source_seq)) };
+}
+async function selectStagedPushSeqsInRange(conn, sourceNodeId, fromSeq, toSeq2) {
+  const stmt = await conn.prepare(
+    `SELECT source_seq FROM "${STAGED_PUSH_CHANGES_TABLE}"
+     WHERE source_node_id = ? AND source_seq >= ? AND source_seq <= ?`
+  );
+  const rows = await stmt.all(sourceNodeId, fromSeq.toString(), toSeq2.toString());
+  return new Set(rows.map((row) => String(row.source_seq)));
+}
+async function selectStagedPushChangesAfter(conn, sourceNodeId, afterSeq, limit) {
+  const stmt = await conn.prepare(
+    `SELECT source_seq, change FROM "${STAGED_PUSH_CHANGES_TABLE}"
+     WHERE source_node_id = ? AND source_seq > ? ORDER BY source_seq ASC LIMIT ?`
+  );
+  return await stmt.all(sourceNodeId, afterSeq.toString(), limit);
+}
+async function deleteStagedPushChanges(conn, sourceNodeId) {
+  const stmt = await conn.prepare(`DELETE FROM "${STAGED_PUSH_CHANGES_TABLE}" WHERE source_node_id = ?`);
+  await stmt.run(sourceNodeId);
+}
+
 // src/core/sync/canonicalise.ts
 function canonicaliseForChecksum(value) {
   return canonicaliseValue(value);
@@ -750,12 +1058,12 @@ var PkResolver = class {
 // 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 SAFE_DDL_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+(?:UNIQUE\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);
 }
-var CREATE_INDEX_TARGETS_RE = /^\s*CREATE\s+INDEX(?:\s+IF\s+NOT\s+EXISTS)?\s+(?:["`[]?[A-Za-z_][A-Za-z0-9_]*["`\]]?\s*\.\s*)?["`[]?([A-Za-z_][A-Za-z0-9_]*)["`\]]?\s+ON\s+(?:["`[]?[A-Za-z_][A-Za-z0-9_]*["`\]]?\s*\.\s*)?["`[]?([A-Za-z_][A-Za-z0-9_]*)/i;
+var CREATE_INDEX_TARGETS_RE = /^\s*CREATE\s+(?:UNIQUE\s+)?INDEX(?:\s+IF\s+NOT\s+EXISTS)?\s+(?:["`[]?[A-Za-z_][A-Za-z0-9_]*["`\]]?\s*\.\s*)?["`[]?([A-Za-z_][A-Za-z0-9_]*)["`\]]?\s+ON\s+(?:["`[]?[A-Za-z_][A-Za-z0-9_]*["`\]]?\s*\.\s*)?["`[]?([A-Za-z_][A-Za-z0-9_]*)/i;
 var DDL_TARGET_RE = /^\s*(?:CREATE\s+TABLE(?:\s+IF\s+NOT\s+EXISTS)?|ALTER\s+TABLE|DROP\s+TABLE(?:\s+IF\s+EXISTS)?|DROP\s+INDEX(?:\s+IF\s+EXISTS)?)\s+(?:["`[]?[A-Za-z_][A-Za-z0-9_]*["`\]]?\s*\.\s*)?["`[]?([A-Za-z_][A-Za-z0-9_]*)/i;
 function ddlTargetsReservedIdentifier(sql) {
   const indexTargets = CREATE_INDEX_TARGETS_RE.exec(sql);
@@ -782,4 +1090,54 @@ function extractDroppedTable(sql) {
   return m?.[1] ?? null;
 }
 
-export { HLC, IDENTIFIER_RE, PkResolver, SEQ_STRING_RE, UPSERT_META_VALUE_SQL, assertSafeIdentifier, canonicaliseForChecksum, deleteAllStagedChanges, deleteChangesBeforeSql, deleteChangesBeforeUpToSeqSql, deleteExpiredDeviceCursors, 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, selectFirstStagedTransactionEnd, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinDeviceCursorBoundary, selectMinPeerAckedSeq, selectNodeChangesAfterSeqSql, selectOutboundChangesSql, selectPeerAckedSeq, selectStagedChangesInRange, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnNames, tableInfoRows, tablePkColumns, updateChangeStampsAfterSeqSql, updateUnstampedChangeStampsSql, upsertDeviceCursor, upsertMetaValue, upsertPeerAckedSeq, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };
+// src/core/sync/change-seqs.ts
+var MAX_CHANGE_SEQ = 9223372036854775807n;
+function assertSeqInRange(seq, label) {
+  if (seq < 0n || seq > MAX_CHANGE_SEQ) {
+    throw new BatchValidationError(`${label} must be a sequence from 0 to ${MAX_CHANGE_SEQ}`);
+  }
+}
+function explicitSeqs(batch, changeSeqs) {
+  if (changeSeqs.length !== batch.changes.length) {
+    throw new BatchValidationError("changeSeqs must hold one sequence for each change");
+  }
+  const seqs = [];
+  let previous = null;
+  for (const [index, seq] of changeSeqs.entries()) {
+    assertSeqInRange(seq, `changeSeqs[${index}]`);
+    if (previous !== null && seq <= previous) {
+      throw new BatchValidationError("changeSeqs must rise strictly");
+    }
+    previous = seq;
+    seqs.push([seq]);
+  }
+  if (changeSeqs[0] !== batch.fromSeq || previous !== batch.toSeq) {
+    throw new BatchValidationError("changeSeqs must start at fromSeq and end at toSeq");
+  }
+  return seqs;
+}
+function attributeChangeSeqs(batch) {
+  assertSeqInRange(batch.fromSeq, "fromSeq");
+  assertSeqInRange(batch.toSeq, "toSeq");
+  if (batch.fromSeq > batch.toSeq) {
+    throw new BatchValidationError("fromSeq must not exceed toSeq");
+  }
+  if (batch.changeSeqs !== void 0) {
+    return explicitSeqs(batch, batch.changeSeqs);
+  }
+  if (batch.txContinues === true) {
+    throw new BatchValidationError("txContinues requires changeSeqs");
+  }
+  const count = batch.changes.length;
+  if (batch.toSeq - batch.fromSeq + 1n === BigInt(count)) {
+    return batch.changes.map((_, index) => [batch.fromSeq + BigInt(index)]);
+  }
+  return batch.changes.map((_, index) => {
+    const seqs = [];
+    if (index === 0) seqs.push(batch.fromSeq);
+    if (index === count - 1 && (index !== 0 || batch.toSeq !== batch.fromSeq)) seqs.push(batch.toSeq);
+    return seqs;
+  });
+}
+
+export { HLC, IDENTIFIER_RE, MAX_CHANGE_SEQ, PkResolver, SEQ_STRING_RE, TABLE_XINFO_HIDDEN, assertSafeIdentifier, attributeChangeSeqs, canonicaliseForChecksum, deleteAllReplacedRows, deleteAllStagedChanges, deleteAppliedChangesAfterSeq, deleteChangesBeforeUpToSeqSql, deleteColumnVersions, deleteColumnVersionsAfterHlc, deleteExpiredDeviceCursors, deleteHistoryChangesAfterHlc, deleteMetaValue, deletePeerState, deletePeerStates, deletePrimaryTermStart, deleteReplacedRowsOfTable, deleteStagedChangesUpToSeq, deleteStagedPushChanges, deleteStampedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplacedRowsTable, ensureReplicationStateTables, ensureStagedChangesTable, ensureStagedPushChangesTable, extractDroppedTable, highestMigrationVersion, indexColumns, insertAppliedChangesFromStagedPush, insertDdlChange, insertMetaValueIfAbsent, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareInsertAppliedChange, prepareInsertMigration, prepareInsertStagedPushChange, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, primaryKeyColumns, referencedTables, replaceMigrationHistory, selectAnchoredTerm, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectDeviceCursorExists, selectFirstStagedTransactionEnd, selectHistoryBase, selectHistoryChangesAfterHlc, selectHistoryTransaction, selectIndexSql, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxAssignedChangeSeq, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxHistoryChangeSeq, selectMaxNodeChangeSeq, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinDeviceCursorBoundary, selectMinPeerAckedSeq, selectNewestHistoryChange, selectNodeChangesAfterSeqSql, selectOrdinaryTableName, selectOutboundChangesSql, selectOutboundHistoryChangesSql, selectPeerAckedSeq, selectPrimaryTermStart, selectQuarantined, selectStagedChangesInRange, selectStagedPushChangesAfter, selectStagedPushSeqsInRange, selectStagedPushTail, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectTriggerSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnsWithGenerated, tableIndexList, tableInfoRows, tablePkColumns, updateChangeStampsAboveMetaSeqSql, updateChangeStampsAfterSeqSql, updateDeviceCursor, upsertAnchoredTerm, upsertDeviceCursor, upsertHistoryBase, upsertMetaMaxChangeSeqSql, upsertMetaValue, upsertMetaValueAndMaxChangeSeqSql, upsertPeerAckedSeq, upsertPrimaryTermStart, upsertQuarantined, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };

package/dist/chunk-75IBRE73.mjs

@@ -0,0 +1,55 @@
+import { withRowCounts, rowCountsOf } from './chunk-E2GRX4ZD.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
+
+// src/core/worker/protocol.ts
+function toWorkerGroupStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: statement.params ? [...statement.params] : [],
+    ...statement.trusted === true ? { trusted: true } : {}
+  };
+}
+var WORKER_CANCELLED_CODE = "WRITER_WORKER_CANCELLED";
+var WORKER_BEGIN_FAILED_CODE = "WRITER_WORKER_BEGIN_FAILED";
+var KINDS_THAT_CARRY_BEGIN = /* @__PURE__ */ new Set([
+  "exec",
+  "run",
+  "get",
+  "all",
+  "allRaw",
+  "allCounted",
+  "getCounted",
+  "allRawCounted",
+  "runBatch",
+  "runBatchSummary"
+]);
+function canCarryBegin(kind) {
+  return KINDS_THAT_CARRY_BEGIN.has(kind);
+}
+function leftTransactionUnbegun(error) {
+  return error.code === WORKER_BEGIN_FAILED_CODE || error.code === WORKER_CANCELLED_CODE;
+}
+var WORKER_COPY_STOPPED_CODE = "WRITER_WORKER_COPY_STOPPED";
+function serializeError(err) {
+  if (err instanceof Error) {
+    const { code, sql } = err;
+    return withRowCounts(
+      {
+        message: err.message,
+        name: err.name,
+        ...typeof code === "string" ? { code } : {},
+        ...typeof sql === "string" ? { sql } : {},
+        ...err instanceof SirannonError ? { sirannonError: true } : {}
+      },
+      rowCountsOf(err)
+    );
+  }
+  return { message: String(err) };
+}
+function deserializeError(error) {
+  const err = error.sirannonError === true && error.code !== void 0 ? new SirannonError(error.message, error.code) : Object.assign(new Error(error.message), error.code === void 0 ? {} : { code: error.code });
+  if (error.name) err.name = error.name;
+  return withRowCounts(err, rowCountsOf(error));
+}
+
+export { WORKER_BEGIN_FAILED_CODE, WORKER_CANCELLED_CODE, WORKER_COPY_STOPPED_CODE, canCarryBegin, deserializeError, leftTransactionUnbegun, serializeError, toWorkerGroupStatement };