@delali/sirannon-db 0.1.8 → 0.2.0

package/dist/{chunk-HHRMRFFR.mjs → chunk-H6PIVVDN.mjs}

@@ -1,6 +1,7 @@
-import { synchronousPragmaValue } from './chunk-CJLYFDP5.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, CDC_TRIGGER_PREFIX, SAFE_INT_BOUND_TEXT } from './chunk-GEZUUIKV.mjs';
-import { SirannonError, ForbiddenSqlError, CDCError } from './chunk-YPYVQJ4C.mjs';
+import { tableColumnNames, tablePkColumns, selectMinChangeSeqSql, selectMaxChangeSeq, deleteChangesBeforeUpToSeqSql, deleteChangesBeforeSql, selectTableExists, ensureChangesTable, ensureMetaTable, insertMetaValueIfAbsent, selectMetaValue, selectChangesAfterSeqSql, selectTableChangesInRangeSql, selectTablesChangesInRangeSql } from './chunk-NVQS53NT.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, CDC_TRIGGER_PREFIX, encodeTaggedValues, decodeTaggedValues, SAFE_INT_BOUND_TEXT } from './chunk-D7LAYTKN.mjs';
+import { synchronousPragmaValue } from './chunk-LFZ37BSX.mjs';
+import { SirannonError, ForbiddenSqlError, CDCError, MigrationError } from './chunk-UC3SCMIN.mjs';
 
 // src/core/bulk-load.ts
 var DEFAULT_LOAD_DURABILITY = "off";
@@ -57,19 +58,106 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/core/cdc/change-log-reader.ts
+var MAX_TRANSACTION_CARRY_ROWS = 5e4;
+function rowToEvent(row) {
+  return {
+    type: row.operation.toLowerCase(),
+    table: row.table_name,
+    row: row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {},
+    oldRow: row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : void 0,
+    seq: BigInt(row.seq),
+    timestamp: row.changed_at,
+    rowId: String(row.row_id),
+    ...row.node_id ? { origin: row.node_id } : {},
+    ...row.hlc ? { hlc: row.hlc } : {},
+    ...row.tx_id ? { txId: row.tx_id } : {}
+  };
+}
+async function pollChanges(conn, cache, changesTable, afterSeq, batchSize) {
+  const stmt = await cache.get(conn, "poll", selectChangesAfterSeqSql(changesTable));
+  const rows = await stmt.all(afterSeq.toString(), batchSize + 1);
+  if (rows.length === 0) return null;
+  const emitted = rows.length > batchSize ? rows.slice(0, batchSize) : rows;
+  const lastEmitted = emitted[emitted.length - 1];
+  const peekedBeyondBatch = rows[batchSize];
+  const openTxId = lastEmitted.tx_id;
+  const events = emitted.map(rowToEvent);
+  let lastSeq = BigInt(lastEmitted.seq);
+  if (peekedBeyondBatch === void 0 || !openTxId || (peekedBeyondBatch.tx_id ?? "") !== openTxId) {
+    return { events, lastSeq, atTxBoundary: true };
+  }
+  let carried = 0;
+  while (carried < MAX_TRANSACTION_CARRY_ROWS) {
+    const tail = await stmt.all(lastSeq.toString(), batchSize);
+    if (tail.length === 0) {
+      return { events, lastSeq, atTxBoundary: true };
+    }
+    for (const row of tail) {
+      if ((row.tx_id ?? "") !== openTxId) {
+        return { events, lastSeq, atTxBoundary: true };
+      }
+      events.push(rowToEvent(row));
+      lastSeq = BigInt(row.seq);
+      carried += 1;
+    }
+    if (tail.length < batchSize) {
+      return { events, lastSeq, atTxBoundary: true };
+    }
+  }
+  return { events, lastSeq, atTxBoundary: false };
+}
+async function readSinceOneTable(conn, cache, changesTable, table, afterSeq, upToSeq, limit) {
+  const stmt = await cache.get(conn, "read_since", selectTableChangesInRangeSql(changesTable));
+  const rows = await stmt.all(table, afterSeq.toString(), upToSeq.toString(), limit);
+  return rows.map(rowToEvent);
+}
+async function readSinceTables(conn, cache, changesTable, tables, afterSeq, upToSeq, limit) {
+  if (tables.length === 0) return [];
+  const stmt = await cache.get(
+    conn,
+    `read_since_tables_${tables.length}`,
+    selectTablesChangesInRangeSql(changesTable, tables.length)
+  );
+  const rows = await stmt.all(...tables, afterSeq.toString(), upToSeq.toString(), limit);
+  return rows.map(rowToEvent);
+}
+
+// src/core/cdc/statement-cache.ts
+var StatementCache = class {
+  cache = /* @__PURE__ */ new WeakMap();
+  async get(conn, key, sql) {
+    let stmts = this.cache.get(conn);
+    if (!stmts) {
+      stmts = /* @__PURE__ */ new Map();
+      this.cache.set(conn, stmts);
+    }
+    const existing = stmts.get(key);
+    if (existing) return existing;
+    const pending = conn.prepare(sql);
+    stmts.set(key, pending);
+    try {
+      return await pending;
+    } catch (err) {
+      stmts.delete(key);
+      throw err;
+    }
+  }
+};
+
 // src/core/cdc/trigger-sql.ts
 async function dropCdcTriggers(conn, table) {
   await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_insert"`);
   await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_update"`);
   await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_delete"`);
 }
-async function installCdcTriggers(conn, changesTable, table, columns, pkColumns, replication) {
+async function installCdcTriggers(conn, changesTable, table, columns, pkColumns) {
   const newJson = buildJsonObject(columns, "NEW");
   const oldJson = buildJsonObject(columns, "OLD");
   const newPk = buildPkRef(pkColumns, "NEW");
   const oldPk = buildPkRef(pkColumns, "OLD");
-  const replCols = replication ? ", node_id, tx_id, hlc" : "";
-  const replVals = replication ? ", '', '', ''" : "";
+  const replCols = ", node_id, tx_id, hlc";
+  const replVals = ", '', '', ''";
   await conn.exec(`
 			CREATE TRIGGER IF NOT EXISTS "${CDC_TRIGGER_PREFIX}${table}_insert"
 			AFTER INSERT ON "${table}"
@@ -128,16 +216,16 @@ var ChangeTracker = class {
   retentionMs;
   changesTable;
   pollBatchSize;
-  replication;
   changesTableReady = false;
+  changesTableEnsured = false;
   watchedTablesCache = null;
-  stmtCache = /* @__PURE__ */ new WeakMap();
+  stmtCache = new StatementCache();
   pruneBoundary = null;
+  lastPollAtTxBoundary = true;
   constructor(options) {
     this.retentionMs = options?.retention ?? DEFAULT_RETENTION_MS;
     this.changesTable = options?.changesTable ?? CHANGES_TABLE;
     this.pollBatchSize = options?.pollBatchSize ?? DEFAULT_POLL_BATCH_SIZE;
-    this.replication = options?.replication ?? false;
     this.assertIdentifier(this.changesTable, "changes table name");
   }
   async watch(conn, table) {
@@ -146,14 +234,14 @@ var ChangeTracker = class {
       throw new ForbiddenSqlError(`Table '${table}' is reserved for Sirannon and cannot be watched`);
     }
     await this.ensureChangesTable(conn);
-    const columns = await this.getColumns(conn, table);
+    const columns = await tableColumnNames(conn, table);
     if (columns.length === 0) {
       throw new CDCError(`Table '${table}' does not exist or has no columns`);
     }
     for (const col of columns) {
       this.assertIdentifier(col, `column name in table '${table}'`);
     }
-    const pkColumns = await this.getPkColumns(conn, table);
+    const pkColumns = await tablePkColumns(conn, table);
     const existing = this.watched.get(table);
     if (existing) {
       const same = existing.columns.length === columns.length && existing.columns.every((col, i) => col === columns[i]);
@@ -161,7 +249,7 @@ var ChangeTracker = class {
         return;
       }
       await conn.transaction(async (txConn) => {
-        await this.dropTriggers(txConn, table);
+        await dropCdcTriggers(txConn, table);
         await this.installTriggers(txConn, table, columns, pkColumns);
       });
     } else {
@@ -174,7 +262,7 @@ var ChangeTracker = class {
     if (!this.watched.has(table)) {
       return;
     }
-    await this.dropTriggers(conn, table);
+    await dropCdcTriggers(conn, table);
     this.watched.delete(table);
     this.watchedTablesCache = null;
   }
@@ -209,7 +297,7 @@ var ChangeTracker = class {
     for (const table of tables) {
       const existing = this.watched.get(table);
       if (!existing) continue;
-      const columns = await this.getColumns(conn, table);
+      const columns = await tableColumnNames(conn, table);
       if (columns.length === 0) {
         continue;
       }
@@ -220,8 +308,8 @@ var ChangeTracker = class {
       if (same) {
         continue;
       }
-      const pkColumns = await this.getPkColumns(conn, table);
-      await this.dropTriggers(conn, table);
+      const pkColumns = await tablePkColumns(conn, table);
+      await dropCdcTriggers(conn, table);
       await this.installTriggers(conn, table, columns, pkColumns);
       this.watched.set(table, { table, columns, pkColumns });
       anyMutated = true;
@@ -256,7 +344,7 @@ var ChangeTracker = class {
       if (!this.watched.has(table)) {
         continue;
       }
-      await this.dropTriggers(conn, table);
+      await dropCdcTriggers(conn, table);
       this.watched.delete(table);
       mutated = true;
     }
@@ -271,22 +359,17 @@ var ChangeTracker = class {
         return [];
       }
     }
-    const stmt = await this.getStmt(
-      conn,
-      "poll",
-      `SELECT seq, table_name, operation, row_id, changed_at, old_data, new_data
-			 FROM "${this.changesTable}"
-			 WHERE seq > ?
-			 ORDER BY seq ASC
-			 LIMIT ?`
-    );
-    const rows = await stmt.all(this.lastSeq.toString(), this.pollBatchSize);
-    if (rows.length === 0) {
+    const result = await pollChanges(conn, this.stmtCache, this.changesTable, this.lastSeq, this.pollBatchSize);
+    if (result === null) {
+      this.lastPollAtTxBoundary = true;
       return [];
     }
-    const events = rows.map((row) => this.rowToEvent(row));
-    this.lastSeq = BigInt(rows[rows.length - 1].seq);
-    return events;
+    this.lastPollAtTxBoundary = result.atTxBoundary;
+    this.lastSeq = result.lastSeq;
+    return result.events;
+  }
+  get pollEndedAtTxBoundary() {
+    return this.lastPollAtTxBoundary;
   }
   /** The highest seq already polled; live subscribers receive events beyond it. */
   get cursor() {
@@ -304,17 +387,17 @@ var ChangeTracker = class {
         return [];
       }
     }
-    const stmt = await this.getStmt(
-      conn,
-      "read_since",
-      `SELECT seq, table_name, operation, row_id, changed_at, old_data, new_data
-			 FROM "${this.changesTable}"
-			 WHERE table_name = ? AND seq > ? AND seq <= ?
-			 ORDER BY seq ASC
-			 LIMIT ?`
-    );
-    const rows = await stmt.all(table, afterSeq.toString(), upToSeq.toString(), limit);
-    return rows.map((row) => this.rowToEvent(row));
+    return readSinceOneTable(conn, this.stmtCache, this.changesTable, table, afterSeq, upToSeq, limit);
+  }
+  async readSinceTables(conn, tables, afterSeq, upToSeq, limit) {
+    if (tables.length === 0) return [];
+    if (!this.changesTableReady) {
+      await this.detectChangesTable(conn);
+      if (!this.changesTableReady) {
+        return [];
+      }
+    }
+    return readSinceTables(conn, this.stmtCache, this.changesTable, tables, afterSeq, upToSeq, limit);
   }
   /** The lowest retained seq, or `null` when the change log is empty. */
   async getMinSeq(conn) {
@@ -324,7 +407,7 @@ var ChangeTracker = class {
         return null;
       }
     }
-    const stmt = await this.getStmt(conn, "min_seq", `SELECT MIN(seq) AS seq FROM "${this.changesTable}"`);
+    const stmt = await this.stmtCache.get(conn, "min_seq", selectMinChangeSeqSql(this.changesTable));
     const row = await stmt.get();
     const seq = row?.seq;
     if (seq === void 0 || seq === null) {
@@ -332,16 +415,6 @@ var ChangeTracker = class {
     }
     return typeof seq === "bigint" ? seq : BigInt(String(seq));
   }
-  rowToEvent(row) {
-    return {
-      type: row.operation.toLowerCase(),
-      table: row.table_name,
-      row: row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {},
-      oldRow: row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : void 0,
-      seq: BigInt(row.seq),
-      timestamp: row.changed_at
-    };
-  }
   async advanceToLatest(conn) {
     if (!this.changesTableReady) {
       await this.detectChangesTable(conn);
@@ -349,13 +422,7 @@ var ChangeTracker = class {
         return;
       }
     }
-    const stmt = await this.getStmt(conn, "latest_seq", `SELECT MAX(seq) AS seq FROM "${this.changesTable}"`);
-    const row = await stmt.get();
-    const seq = row?.seq;
-    if (seq === void 0 || seq === null) {
-      return;
-    }
-    const latestSeq = typeof seq === "bigint" ? seq : BigInt(String(seq));
+    const latestSeq = await selectMaxChangeSeq(conn, this.changesTable);
     if (latestSeq > this.lastSeq) {
       this.lastSeq = latestSeq;
     }
@@ -370,15 +437,15 @@ var ChangeTracker = class {
     const cutoff = Date.now() / 1e3 - this.retentionMs / 1e3;
     const seqBound = this.computeSeqBound();
     if (seqBound !== null) {
-      const stmt2 = await this.getStmt(
+      const stmt2 = await this.stmtCache.get(
         conn,
         "cleanup_coordinated",
-        `DELETE FROM "${this.changesTable}" WHERE changed_at < ? AND seq <= ?`
+        deleteChangesBeforeUpToSeqSql(this.changesTable)
       );
       const result2 = await stmt2.run(cutoff, seqBound.toString());
       return result2.changes;
     }
-    const stmt = await this.getStmt(conn, "cleanup", `DELETE FROM "${this.changesTable}" WHERE changed_at < ?`);
+    const stmt = await this.stmtCache.get(conn, "cleanup", deleteChangesBeforeSql(this.changesTable));
     const result = await stmt.run(cutoff);
     return result.changes;
   }
@@ -415,94 +482,85 @@ var ChangeTracker = class {
     }
   }
   async detectChangesTable(conn) {
-    const stmt = await conn.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?");
-    const row = await stmt.get(this.changesTable);
-    if (row) {
+    if (await selectTableExists(conn, this.changesTable)) {
       this.changesTableReady = true;
     }
   }
   async ensureChangesTable(conn) {
-    if (this.changesTableReady) {
+    if (this.changesTableEnsured) {
       return;
     }
-    if (this.replication) {
-      await 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 conn.exec(
-        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_changed_at" ON "${this.changesTable}" (changed_at)`
-      );
-      await conn.exec(
-        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_node_id" ON "${this.changesTable}" (node_id)`
-      );
-      await conn.exec(`CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_hlc" ON "${this.changesTable}" (hlc)`);
-    } else {
-      await 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
-)`);
-      await conn.exec(
-        `CREATE INDEX IF NOT EXISTS "idx_${this.changesTable}_changed_at" ON "${this.changesTable}" (changed_at)`
-      );
-    }
+    await ensureChangesTable(conn, this.changesTable);
+    this.changesTableEnsured = true;
     this.changesTableReady = true;
   }
-  async getColumns(conn, table) {
-    const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
-    const info = await stmt.all();
-    return info.map((col) => col.name);
-  }
-  async getPkColumns(conn, table) {
-    const stmt = await conn.prepare(`PRAGMA table_info("${table}")`);
-    const info = await stmt.all();
-    return info.filter((col) => col.pk > 0).sort((a, b) => a.pk - b.pk).map((col) => col.name);
-  }
-  async dropTriggers(conn, table) {
-    await dropCdcTriggers(conn, table);
-  }
-  async getStmt(conn, key, sql) {
-    let stmts = this.stmtCache.get(conn);
-    if (!stmts) {
-      stmts = /* @__PURE__ */ new Map();
-      this.stmtCache.set(conn, stmts);
-    }
-    const existing = stmts.get(key);
-    if (existing) return existing;
-    const pending = conn.prepare(sql);
-    stmts.set(key, pending);
-    try {
-      return await pending;
-    } catch (err) {
-      stmts.delete(key);
-      throw err;
-    }
-  }
   async installTriggers(conn, table, columns, pkColumns) {
-    await installCdcTriggers(conn, this.changesTable, table, columns, pkColumns, this.replication);
+    await installCdcTriggers(conn, this.changesTable, table, columns, pkColumns);
   }
 };
 
+// src/core/migrations/checksum.ts
+var FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
+var FNV_PRIME = 0x100000001b3n;
+var MASK_64 = 0xffffffffffffffffn;
+function migrationChecksum(sql) {
+  const bytes = new TextEncoder().encode(sql.replace(/\r\n?/g, "\n").trim());
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = (hash ^ BigInt(bytes[i])) * FNV_PRIME & MASK_64;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function migrationContentChecksum(migration) {
+  return typeof migration.up === "string" ? migrationChecksum(migration.up) : null;
+}
+function reconcileMigrationChecksums(migrations, applied) {
+  const backfills = [];
+  for (const migration of migrations) {
+    const row = applied.get(migration.version);
+    if (!row) continue;
+    const computed = migrationContentChecksum(migration);
+    if (computed === null) continue;
+    if (row.checksum === null) {
+      backfills.push({ version: migration.version, checksum: computed });
+      continue;
+    }
+    if (row.checksum !== computed) {
+      throw new MigrationError(
+        `Migration ${migration.version}_${migration.name} was modified after it was applied`,
+        migration.version,
+        "MIGRATION_CHECKSUM_MISMATCH"
+      );
+    }
+  }
+  return backfills;
+}
+
+// src/core/random-hex.ts
+function randomHex(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  globalThis.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+
+// src/core/cdc/epoch.ts
+var EPOCH_KEY = "cdc_epoch";
+async function ensureCdcEpoch(conn) {
+  await ensureMetaTable(conn);
+  await insertMetaValueIfAbsent(conn, EPOCH_KEY, randomHex(16));
+  const value = await selectMetaValue(conn, EPOCH_KEY);
+  if (value === null || value.length === 0) {
+    throw new CDCError("Failed to read the CDC epoch identifier");
+  }
+  return value;
+}
+
 // src/core/cdc/subscription.ts
 var SubscriptionManager = class {
   nextId = 1;
   subscriptions = /* @__PURE__ */ new Map();
   byTable = /* @__PURE__ */ new Map();
+  batchEndListeners = /* @__PURE__ */ new Set();
   subscribe(table, filter, callback) {
     const id = this.nextId++;
     this.subscriptions.set(id, { id, table, filter, callback });
@@ -532,16 +590,29 @@ var SubscriptionManager = class {
       for (const id of ids) {
         const sub = this.subscriptions.get(id);
         if (!sub) continue;
-        if (sub.filter && !changeMatchesFilter(event, sub.filter)) {
-          continue;
-        }
+        const delivered = sub.filter === void 0 ? event : filteredChange(event, sub.filter);
+        if (delivered === null) continue;
         try {
-          sub.callback(event);
+          sub.callback(delivered);
         } catch {
         }
       }
     }
   }
+  addBatchEndListener(listener) {
+    this.batchEndListeners.add(listener);
+    return () => {
+      this.batchEndListeners.delete(listener);
+    };
+  }
+  endBatch(atTxBoundary) {
+    for (const listener of this.batchEndListeners) {
+      try {
+        listener(atTxBoundary);
+      } catch {
+      }
+    }
+  }
   get size() {
     return this.subscriptions.size;
   }
@@ -579,6 +650,7 @@ function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive)
       if (events.length > 0) {
         manager.dispatch(events);
       }
+      manager.endBatch(tracker.pollEndedAtTxBoundary);
       consecutiveErrors = 0;
       tickCount++;
       if (tickCount >= CLEANUP_INTERVAL_TICKS) {
@@ -604,10 +676,23 @@ function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive)
   };
   return stop;
 }
-function changeMatchesFilter(event, filter) {
-  const target = event.type === "delete" ? event.oldRow ?? {} : event.row;
+function filteredChange(event, filter) {
+  const matchedBefore = event.type !== "insert" && event.oldRow !== void 0 && rowMatchesFilter(event.oldRow, filter);
+  const matchedAfter = event.type !== "delete" && rowMatchesFilter(event.row, filter);
+  if (!matchedBefore && !matchedAfter) return null;
+  if (matchedBefore && matchedAfter) return event;
+  if (matchedAfter) {
+    if (event.type === "insert") return event;
+    const entering = { ...event, type: "insert" };
+    entering.oldRow = void 0;
+    return entering;
+  }
+  if (event.type === "delete") return event;
+  return { ...event, type: "delete", row: {} };
+}
+function rowMatchesFilter(row, filter) {
   for (const [key, value] of Object.entries(filter)) {
-    if (!filterValueMatches(target[key], value)) {
+    if (!filterValueMatches(row[key], value)) {
       return false;
     }
   }
@@ -631,4 +716,130 @@ function filterValueMatches(rowValue, filterValue) {
   return false;
 }
 
-export { ChangeTracker, SubscriptionBuilderImpl, SubscriptionManager, changeMatchesFilter, isBulkLoadDurability, runBulkLoad, startPolling };
+// src/core/cdc/primed-subscription.ts
+var REPLAY_BATCH_SIZE = 1e3;
+var DEFAULT_PRIME_BUFFER_LIMIT = 1e4;
+var DEFAULT_PRIME_BUFFER_BYTES = 16 * 1048576;
+function approxEventBytes(event) {
+  let bytes = 0;
+  if (event.row) bytes += JSON.stringify(encodeTaggedValues(event.row)).length;
+  if (event.oldRow) bytes += JSON.stringify(encodeTaggedValues(event.oldRow)).length;
+  return bytes;
+}
+function needsResync(sinceSeq, minSeq, boundary) {
+  if (sinceSeq >= boundary) return false;
+  if (minSeq === null) return true;
+  return minSeq > sinceSeq + 1n;
+}
+var PrimedSubscription = class {
+  constructor(sinceSeq, deliver, onOverload, bufferLimit = DEFAULT_PRIME_BUFFER_LIMIT, bufferByteLimit = DEFAULT_PRIME_BUFFER_BYTES) {
+    this.sinceSeq = sinceSeq;
+    this.deliver = deliver;
+    this.onOverload = onOverload;
+    this.bufferLimit = bufferLimit;
+    this.bufferByteLimit = bufferByteLimit;
+  }
+  mode = "priming";
+  buffer = [];
+  bufferBytes = 0;
+  bufferLimit;
+  bufferByteLimit;
+  onLiveEvent(event) {
+    if (this.mode === "stopped") return;
+    if (this.mode === "live") {
+      this.emit(event);
+      return;
+    }
+    const nextBytes = this.bufferBytes + approxEventBytes(event);
+    if (this.buffer.length >= this.bufferLimit || nextBytes > this.bufferByteLimit) {
+      this.stop();
+      this.onOverload();
+      return;
+    }
+    this.buffer.push(event);
+    this.bufferBytes = nextBytes;
+  }
+  replay(tracker, conn, table, filter, boundary) {
+    return this.replayTables(tracker, conn, [table], filter, boundary);
+  }
+  async replayTables(tracker, conn, tables, filter, boundary) {
+    let cursor = this.sinceSeq;
+    while (this.mode === "priming" && cursor < boundary) {
+      const events = await tracker.readSinceTables(conn, tables, cursor, boundary, REPLAY_BATCH_SIZE);
+      if (events.length === 0) break;
+      for (const event of events) {
+        const delivered = filter === void 0 ? event : filteredChange(event, filter);
+        if (delivered === null) continue;
+        if (!this.emit(delivered)) return;
+      }
+      const lastEvent = events[events.length - 1];
+      if (lastEvent === void 0) break;
+      cursor = lastEvent.seq;
+      if (events.length < REPLAY_BATCH_SIZE) break;
+    }
+  }
+  goLive() {
+    if (this.mode !== "priming") return;
+    const pending = this.buffer;
+    this.buffer = [];
+    for (const event of pending) {
+      if (!this.emit(event)) return;
+    }
+    if (this.mode === "priming") {
+      this.mode = "live";
+    }
+  }
+  emit(event) {
+    if (this.mode === "stopped") return false;
+    if (event.seq <= this.sinceSeq) return true;
+    if (!this.deliver(event)) {
+      this.stop();
+      return false;
+    }
+    return true;
+  }
+  stop() {
+    this.mode = "stopped";
+    this.buffer = [];
+    this.bufferBytes = 0;
+  }
+};
+
+// src/core/cdc/transaction-grouper.ts
+var TransactionGrouper = class {
+  constructor(deliver) {
+    this.deliver = deliver;
+  }
+  pending;
+  stopped = false;
+  receive(event) {
+    if (this.stopped) return false;
+    const held = this.pending;
+    this.pending = void 0;
+    if (held !== void 0 && !this.emit(held, held.txId !== event.txId)) {
+      return false;
+    }
+    if (event.txId === void 0) {
+      return this.emit(event, true);
+    }
+    this.pending = event;
+    return true;
+  }
+  flush(atTxBoundary) {
+    if (this.stopped) return false;
+    if (!atTxBoundary) return true;
+    const held = this.pending;
+    this.pending = void 0;
+    if (held === void 0) return true;
+    return this.emit(held, true);
+  }
+  emit(event, txEnd) {
+    const outgoing = txEnd && event.txEnd !== true ? { ...event, txEnd: true } : event;
+    if (this.deliver(outgoing)) return true;
+    this.stopped = true;
+    this.pending = void 0;
+    return false;
+  }
+};
+
+export { ChangeTracker, PrimedSubscription, SubscriptionBuilderImpl, SubscriptionManager, TransactionGrouper, ensureCdcEpoch, filteredChange, isBulkLoadDurability, migrationChecksum, migrationContentChecksum, needsResync, randomHex, reconcileMigrationChecksums, runBulkLoad, startPolling };