@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/core/index.mjs

@@ -1,15 +1,22 @@
-import { runBulkLoad, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling } from '../chunk-HHRMRFFR.mjs';
-export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-HHRMRFFR.mjs';
-export { defineDriver } from '../chunk-BNUTBHHH.mjs';
-import { DEFAULT_SYNCHRONOUS } from '../chunk-CJLYFDP5.mjs';
-export { DEFAULT_SYNCHRONOUS, isSynchronousLevel, synchronousPragmaValue } from '../chunk-CJLYFDP5.mjs';
-import { Transaction } from '../chunk-TKGHYWQ6.mjs';
-export { Transaction } from '../chunk-TKGHYWQ6.mjs';
-import { query, queryForWire, queryOne, executeBatch, executeBatchSummary, execute, bindParams, executeGroup } from '../chunk-CW6S3WL5.mjs';
-export { execute, executeBatch, query, queryOne } from '../chunk-CW6S3WL5.mjs';
-import { MIGRATIONS_TABLE } from '../chunk-GEZUUIKV.mjs';
-import { SirannonError, ConnectionPoolError, MigrationError, ReadOnlyError, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError, WriteOverloadError, ExtensionError } from '../chunk-YPYVQJ4C.mjs';
-export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, ForbiddenSqlError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError, WriteOverloadError } from '../chunk-YPYVQJ4C.mjs';
+import { Transaction, LWWResolver, REMOTE_ORIGIN_NODE_ID, BatchReader, BatchApplier, recordLocalColumnVersions, HLC, loadPersistedHlc, isWellFormedHlc, HLC_CLOCK_META_KEY } from '../chunk-HR5CWTLC.mjs';
+export { Transaction } from '../chunk-HR5CWTLC.mjs';
+import { executeBatch, executeBatchSummary, execute, bindParams, executeGroup, query, queryForWire, queryOne } from '../chunk-JZGINXTN.mjs';
+export { execute, executeBatch, query, queryOne } from '../chunk-JZGINXTN.mjs';
+import { tokenizeSql, unsupported, findClauses, readSource, readSortTerms, readWindow, readSelectItems, parameterName } from '../chunk-JU64Y7HM.mjs';
+import { reconcileMigrationChecksums, migrationContentChecksum, runBulkLoad, ensureCdcEpoch, SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling, randomHex, TransactionGrouper, PrimedSubscription } from '../chunk-H6PIVVDN.mjs';
+export { ChangeTracker, isBulkLoadDurability, runBulkLoad } from '../chunk-H6PIVVDN.mjs';
+import { ensureMigrationsTable, prepareUpdateMigrationChecksum, prepareInsertMigration, selectAppliedMigrationsNewestFirst, prepareDeleteMigration, selectAppliedMigrations, tableInfoRows, selectTableSql, selectTableExists, selectMetaValue, upsertMetaValue, SEQ_STRING_RE, replaceMigrationHistory, highestMigrationVersion, selectCountOutboundChanges, ensureMetaTable, ensureChangesTable, ensureBatchApplyTables, PkResolver, selectMaxChangeSeq, selectMaxAppliedSourceSeq, insertMetaValueIfAbsent, selectMaxChangeHlc, updateUnstampedChangeStampsSql, UPSERT_META_VALUE_SQL, setForeignKeysEnabled, IDENTIFIER_RE, validateDdlSafety, ensureStagedChangesTable, upsertStagedChangeSql, selectFirstStagedTransactionEnd, deleteStagedChangesUpToSeq, selectMaxStagedSeq, deleteAllStagedChanges, deleteMetaValue, assertSafeIdentifier, selectStagedChangesInRange } from '../chunk-NVQS53NT.mjs';
+import { ReplicationError } from '../chunk-5NOIGN5Y.mjs';
+import { MIGRATIONS_TABLE, LIVE_PROBE_TABLE_PREFIX, META_TABLE, CHANGES_TABLE, assertSqlAllowed, INTERNAL_TABLE_PREFIX, encodeTaggedValues, decodeTaggedValues } from '../chunk-D7LAYTKN.mjs';
+import '../chunk-GVCNMPOS.mjs';
+export { defineDriver } from '../chunk-FHWTZFI4.mjs';
+import { DEFAULT_SYNCHRONOUS } from '../chunk-LFZ37BSX.mjs';
+export { DEFAULT_SYNCHRONOUS, isSynchronousLevel, synchronousPragmaValue } from '../chunk-LFZ37BSX.mjs';
+import { LAZY_DOWN_SQL, parseMigrationFilename } from '../chunk-LNY2VVHE.mjs';
+export { MIGRATION_FILENAME_PATTERN, parseMigrationFilename } from '../chunk-LNY2VVHE.mjs';
+import { resolveEffectiveBaseline, planPendingMigrations, SQLITE_USER_VERSION_MAX, applyBaselineOption } from '../chunk-67M7KAH6.mjs';
+import { SirannonError, ConnectionPoolError, MigrationError, ReadOnlyError, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError, CDCError, ExtensionError, WriteOverloadError } from '../chunk-UC3SCMIN.mjs';
+export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, ForbiddenSqlError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, RequestDeniedError, SirannonError, TransactionError, WriteOverloadError } from '../chunk-UC3SCMIN.mjs';
 
 // src/core/connection-pool.ts
 async function closeAllSilently(connections) {
@@ -202,25 +209,170 @@ var CdcAwareTransaction = class extends Transaction {
   }
 };
 
+// src/core/cdc/read-position.ts
+var TOKEN_VERSION = "1";
+var HEX_RE = /^[0-9a-f]+$/;
+function encodeReadPosition(position) {
+  if (!HEX_RE.test(position.epoch)) {
+    throw new CDCError(`Cannot issue a read position for epoch '${position.epoch}': an epoch is lower-case hex`);
+  }
+  if (position.seq < 0n) {
+    throw new CDCError("Cannot issue a read position for a negative change-log sequence");
+  }
+  return toHex(`${TOKEN_VERSION}:${position.epoch}:${position.seq.toString()}`);
+}
+async function readAtPosition(conn, epoch, read) {
+  return conn.transaction(async (txConn) => {
+    const value = await read(txConn);
+    const seq = await selectTableExists(txConn, CHANGES_TABLE) ? await selectMaxChangeSeq(txConn) : 0n;
+    return { value, position: encodeReadPosition({ epoch, seq }), seq };
+  });
+}
+function toHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += value.charCodeAt(i).toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/core/sync/stamper.ts
+var NODE_ID_META_KEY = "node_id";
+var SyncStamper = class _SyncStamper {
+  constructor(nodeId, hlc, changesTable) {
+    this.nodeId = nodeId;
+    this.hlc = hlc;
+    this.changesTable = changesTable;
+  }
+  static async init(conn, changesTable = CHANGES_TABLE) {
+    await ensureMetaTable(conn);
+    await insertMetaValueIfAbsent(conn, NODE_ID_META_KEY, randomHex(16));
+    const nodeId = await selectMetaValue(conn, NODE_ID_META_KEY);
+    if (nodeId === null || nodeId.length === 0) {
+      throw new CDCError("Failed to read the persisted node identity");
+    }
+    const hlc = new HLC(nodeId);
+    const persisted = await loadPersistedHlc(conn);
+    if (persisted !== null) {
+      hlc.receive(persisted);
+    }
+    const persistedMax = await selectMaxChangeHlc(conn, changesTable);
+    if (persistedMax !== null && isWellFormedHlc(persistedMax)) {
+      hlc.receive(persistedMax);
+    }
+    return new _SyncStamper(nodeId, hlc, changesTable);
+  }
+  stampStatements(options) {
+    const hlcValue = this.hlc.now();
+    const txId = randomHex(16);
+    const statements = [
+      {
+        sql: updateUnstampedChangeStampsSql(this.changesTable),
+        params: [this.nodeId, txId, hlcValue],
+        trusted: true
+      }
+    ];
+    if (options?.persistClock !== false) {
+      statements.push({
+        sql: UPSERT_META_VALUE_SQL,
+        params: [HLC_CLOCK_META_KEY, hlcValue],
+        trusted: true
+      });
+    }
+    return statements;
+  }
+  async applyStamps(txConn) {
+    for (const statement of this.stampStatements()) {
+      const stmt = await txConn.prepare(statement.sql);
+      await stmt.run(...statement.params);
+    }
+  }
+};
+
 // src/core/database-cdc.ts
 var DatabaseCdcController = class {
-  constructor(runExclusive, acquireWriter, pollInterval, retention) {
+  constructor(runExclusive, acquireWriter, pollInterval, retention, openSnapshotConnection) {
     this.runExclusive = runExclusive;
     this.acquireWriter = acquireWriter;
     this.pollInterval = pollInterval;
     this.retention = retention;
+    this.openSnapshotConnection = openSnapshotConnection;
   }
   tracker = null;
-  subscriptions = null;
+  subscriptionManager = null;
+  liveConnRequest = null;
   stopPolling = null;
+  stamper = null;
+  epochRequest = null;
+  ensureEpoch() {
+    this.epochRequest ??= this.runExclusive(() => ensureCdcEpoch(this.acquireWriter())).catch((err) => {
+      this.epochRequest = null;
+      throw err;
+    });
+    return this.epochRequest;
+  }
+  async readAtPositionWith(read) {
+    const epoch = await this.ensureEpoch();
+    const open = this.openSnapshotConnection;
+    if (open === null) {
+      return this.runExclusive(() => readAtPosition(this.acquireWriter(), epoch, read));
+    }
+    const conn = await open();
+    try {
+      return await readAtPosition(conn, epoch, read);
+    } finally {
+      await conn.close().catch(() => {
+      });
+    }
+  }
+  async liveConnection() {
+    const open = this.openSnapshotConnection;
+    if (open === null) {
+      return { conn: this.acquireWriter(), run: this.runExclusive };
+    }
+    this.liveConnRequest ??= open().catch((err) => {
+      this.liveConnRequest = null;
+      throw err;
+    });
+    return { conn: await this.liveConnRequest, run: (op) => op() };
+  }
+  async closeLiveConnection() {
+    const request = this.liveConnRequest;
+    if (request === null) return;
+    this.liveConnRequest = null;
+    await request.then((conn) => conn.close()).catch(() => {
+    });
+  }
+  get subscriptions() {
+    return this.subscriptionManager;
+  }
   get changeTracker() {
     return this.tracker;
   }
   async watch(table) {
     const { tracker } = this.ensure();
-    await this.runExclusive(() => tracker.watch(this.acquireWriter(), table));
+    await this.runExclusive(async () => {
+      await tracker.watch(this.acquireWriter(), table);
+      await this.ensureStamper();
+    });
     this.ensurePolling();
   }
+  async ensureStamper() {
+    this.stamper ??= await SyncStamper.init(this.acquireWriter());
+    return this.stamper;
+  }
+  async ensureStamping() {
+    if (this.stamper) return;
+    await this.runExclusive(() => this.ensureStamper());
+  }
+  stampStatements(options) {
+    return this.stamper ? this.stamper.stampStatements(options) : null;
+  }
+  async applyStamps(txConn) {
+    if (this.stamper) {
+      await this.stamper.applyStamps(txConn);
+    }
+  }
   async unwatch(table) {
     const tracker = this.tracker;
     if (!tracker) return;
@@ -239,7 +391,11 @@ var DatabaseCdcController = class {
       return Transaction.run(writer, fn);
     }
     const state = { sawDdl: false, droppedTables: [] };
-    const result = await writer.transaction((txConn) => fn(new CdcAwareTransaction(txConn, tracker, state)));
+    const result = await writer.transaction(async (txConn) => {
+      const value = await fn(new CdcAwareTransaction(txConn, tracker, state));
+      await this.applyStamps(txConn);
+      return value;
+    });
     if (state.sawDdl && state.droppedTables.length > 0) {
       await tracker.pruneDroppedTables(writer, state.droppedTables);
     }
@@ -253,18 +409,18 @@ var DatabaseCdcController = class {
   }
   ensure() {
     const tracker = this.tracker ?? new ChangeTracker({ retention: this.retention });
-    const subscriptions = this.subscriptions ?? new SubscriptionManager();
+    const subscriptions = this.subscriptionManager ?? new SubscriptionManager();
     this.tracker = tracker;
-    this.subscriptions = subscriptions;
+    this.subscriptionManager = subscriptions;
     return { tracker, subscriptions };
   }
   ensurePolling() {
     if (this.stopPolling) return;
-    if (!this.tracker || !this.subscriptions) return;
+    if (!this.tracker || !this.subscriptionManager) return;
     this.stopPolling = startPolling(
       this.acquireWriter(),
       this.tracker,
-      this.subscriptions,
+      this.subscriptionManager,
       this.pollInterval,
       void 0,
       this.runExclusive
@@ -310,7 +466,6 @@ var DatabaseObserver = class {
     this.parentHooks = parentHooks;
     this.metrics = metrics;
   }
-  /** False lets a caller skip the timing calls on a path where nothing would read them. */
   get observesQueries() {
     return this.metrics !== null || this.localHooks.has("beforeQuery") || this.localHooks.has("afterQuery") || (this.parentHooks?.has("beforeQuery") ?? false) || (this.parentHooks?.has("afterQuery") ?? false);
   }
@@ -327,12 +482,6 @@ var DatabaseObserver = class {
     if (!this.metrics) return op();
     return this.metrics.trackQuery(op, { databaseId: this.databaseId, sql });
   }
-  /**
-   * Reports each statement separately, since a hook filtering on SQL has no other
-   * way to see them. They share the transaction's duration because the group runs
-   * them back to back under one commit and no statement has a duration of its own,
-   * which is already what a grouped {@link Database.execute} reports.
-   */
   async withTransactionHooks(statements, op) {
     for (const statement of statements) this.fireBefore(statement.sql, statement.params);
     const start = performance.now();
@@ -362,32 +511,497 @@ var DatabaseObserver = class {
   }
 };
 
-// src/core/extension-loader.ts
-async function loadExtension(driver, writer, extensionPath) {
-  if (!driver.capabilities.extensions || !driver.resolveExtensionPath) {
-    throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
+// src/core/migrations/schema-version.ts
+async function readSchemaVersion(conn) {
+  const stmt = await conn.prepare("PRAGMA user_version");
+  const row = await stmt.get();
+  return row === void 0 ? 0 : Number(row.user_version);
+}
+async function writeSchemaVersion(conn, version) {
+  if (!Number.isSafeInteger(version) || version < 0 || version > SQLITE_USER_VERSION_MAX) {
+    throw new SirannonError(
+      `Schema version is outside the PRAGMA user_version range: ${version}`,
+      "INTERNAL_SCHEMA_ERROR"
+    );
   }
-  if (!extensionPath || extensionPath.includes("\0")) {
-    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
+  await conn.exec(`PRAGMA user_version = ${version}`);
+}
+async function mirrorSchemaVersion(conn, version) {
+  if (version > SQLITE_USER_VERSION_MAX) return;
+  await writeSchemaVersion(conn, version);
+}
+async function syncSchemaVersion(conn, expected) {
+  if (expected > SQLITE_USER_VERSION_MAX) return;
+  const current = await readSchemaVersion(conn);
+  if (current !== expected) {
+    await writeSchemaVersion(conn, expected);
   }
-  for (let i = 0; i < extensionPath.length; i++) {
-    if (extensionPath.charCodeAt(i) <= 31) {
-      throw new ExtensionError(extensionPath, "Extension path contains control characters");
+}
+
+// src/core/sync/snapshot-apply.ts
+var SNAPSHOT_STATE_META_KEY = "device_sync_snapshot_state";
+var SNAPSHOT_STATE_LOADING = "loading";
+function assertTableNames(tables) {
+  for (const table of tables) {
+    if (!IDENTIFIER_RE.test(table)) {
+      throw new ReplicationError(`Invalid table name: ${table}`);
     }
   }
-  const segments = extensionPath.split(/[/\\]/);
-  if (segments.includes("..")) {
-    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
+}
+async function snapshotLoadPending(conn) {
+  if (!await selectTableExists(conn, META_TABLE)) return false;
+  return await selectMetaValue(conn, SNAPSHOT_STATE_META_KEY) !== null;
+}
+async function beginSnapshotLoad(conn, tables, tracker) {
+  assertTableNames(tables);
+  await ensureMetaTable(conn);
+  await upsertMetaValue(conn, SNAPSHOT_STATE_META_KEY, SNAPSHOT_STATE_LOADING);
+  await setForeignKeysEnabled(conn, false);
+  await ensureStagedChangesTable(conn);
+  await conn.transaction(async (tx) => {
+    await deleteAllStagedChanges(tx);
+    for (const table of tables) {
+      await tracker?.unwatch(tx, table);
+    }
+    const reversed = [...tables].reverse();
+    for (const table of reversed) {
+      await tx.exec(`DROP TABLE IF EXISTS "${table}"`);
+    }
+  });
+}
+async function applySnapshotSchema(conn, schema) {
+  for (const ddl of schema) {
+    if (!validateDdlSafety(ddl)) {
+      throw new ReplicationError(`Snapshot schema statement failed safety validation: ${ddl.slice(0, 120)}`);
+    }
   }
-  const resolved = driver.resolveExtensionPath(extensionPath);
+  for (const ddl of schema) {
+    const rewritten = ddl.replace(/^\s*CREATE\s+TABLE\s+(?!IF\s+NOT\s+EXISTS)/i, "CREATE TABLE IF NOT EXISTS ").replace(/^\s*CREATE\s+(UNIQUE\s+)?INDEX\s+(?!IF\s+NOT\s+EXISTS)/i, "CREATE $1INDEX IF NOT EXISTS ");
+    await conn.exec(rewritten);
+  }
+}
+async function loadSnapshotPage(conn, table, rows) {
+  if (!IDENTIFIER_RE.test(table)) {
+    throw new ReplicationError(`Invalid table name: ${table}`);
+  }
+  if (rows.length === 0) return;
+  const columns = Object.keys(rows[0]);
+  if (columns.length === 0) {
+    throw new ReplicationError(`Snapshot page for table '${table}' carries rows without columns`);
+  }
+  for (const column of columns) {
+    if (!IDENTIFIER_RE.test(column) && column !== "rowid") {
+      throw new ReplicationError(`Invalid column name in snapshot page for table '${table}': ${column}`);
+    }
+  }
+  const columnSet = new Set(columns);
+  for (const row of rows) {
+    const keys = Object.keys(row);
+    if (keys.length !== columns.length || keys.some((key) => !columnSet.has(key))) {
+      throw new ReplicationError(`Snapshot page rows for table '${table}' do not share one column set`);
+    }
+  }
+  const columnList = columns.map((column) => `"${column}"`).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  await conn.transaction(async (tx) => {
+    const insert = await tx.prepare(`INSERT INTO "${table}" (${columnList}) VALUES (${placeholders})`);
+    for (const row of rows) {
+      await insert.run(...columns.map((column) => row[column]));
+    }
+  });
+}
+async function endSnapshotLoad(conn, tables, tracker) {
+  assertTableNames(tables);
+  for (const table of tables) {
+    await tracker?.watch(conn, table);
+  }
+  await setForeignKeysEnabled(conn, true);
+  await deleteMetaValue(conn, SNAPSHOT_STATE_META_KEY);
+}
+async function abortSnapshotLoad(conn) {
+  await setForeignKeysEnabled(conn, true);
+}
+
+// src/core/sync/staged-pull.ts
+var STAGED_APPLY_BATCH_ROWS = 500;
+async function stagePulledChanges(conn, events) {
+  if (events.length === 0) return null;
+  await ensureStagedChangesTable(conn);
+  let maxSeq2 = null;
+  await conn.transaction(async (tx) => {
+    const stmt = await tx.prepare(upsertStagedChangeSql());
+    for (const event of events) {
+      await stmt.run(
+        event.seq.toString(),
+        event.table,
+        event.type,
+        event.rowId ?? "",
+        event.timestamp,
+        event.oldRow === void 0 ? null : JSON.stringify(encodeTaggedValues(event.oldRow)),
+        event.type === "delete" ? null : JSON.stringify(encodeTaggedValues(event.row)),
+        event.origin ?? "",
+        event.txId ?? "",
+        event.hlc ?? "",
+        event.txEnd === true ? 1 : 0
+      );
+      if (maxSeq2 === null || event.seq > maxSeq2) {
+        maxSeq2 = event.seq;
+      }
+    }
+  });
+  return maxSeq2;
+}
+async function applyStagedTransactions(conn, applier, options) {
+  await ensureStagedChangesTable(conn);
+  let appliedThrough = null;
+  while (true) {
+    const head = await selectFirstStagedTransactionEnd(conn);
+    if (head === null) break;
+    const endSeq = head.seq;
+    const result = await applier.applyStagedGroup({
+      source: {
+        nextBatch: (afterSeq) => readStagedEntries(conn, afterSeq, endSeq)
+      },
+      resolver: options.resolver,
+      withinTx: options.withinTx === void 0 ? void 0 : (tx) => options.withinTx?.(tx, endSeq) ?? Promise.resolve()
+    });
+    if (result.maxHlc !== "") {
+      await applier.mergeHlc(result.maxHlc);
+    }
+    if (options.onChange) {
+      await emitStagedEvents(conn, endSeq, options.onChange);
+    }
+    await deleteStagedChangesUpToSeq(conn, endSeq);
+    appliedThrough = endSeq;
+  }
+  return appliedThrough;
+}
+async function recoverStagedPull(conn, applier, appliedFloor, options) {
+  await ensureStagedChangesTable(conn);
+  if (appliedFloor !== null) {
+    await deleteStagedChangesUpToSeq(conn, appliedFloor);
+  }
+  let appliedThrough = null;
+  let applyError = null;
   try {
-    const escaped = resolved.replace(/'/g, "''");
-    await writer.exec(`SELECT load_extension('${escaped}')`);
+    appliedThrough = await applyStagedTransactions(conn, applier, options);
   } catch (err) {
-    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+    applyError = err;
+  }
+  const stagedMax = await selectMaxStagedSeq(conn);
+  const appliedSeq = maxSeq(appliedFloor, appliedThrough);
+  return { resumeSeq: maxSeq(appliedSeq, stagedMax), appliedSeq, applyError };
+}
+function maxSeq(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return a > b ? a : b;
+}
+async function readStagedEntries(conn, afterSeq, upToSeq) {
+  const rows = await selectStagedChangesInRange(conn, afterSeq, upToSeq, STAGED_APPLY_BATCH_ROWS);
+  return rows.map((row) => ({ seq: BigInt(row.seq), change: rowToReplicationChange(row) }));
+}
+function rowToReplicationChange(row) {
+  return {
+    table: row.table_name,
+    operation: row.operation,
+    rowId: row.row_id,
+    primaryKey: {},
+    hlc: row.hlc,
+    txId: row.tx_id,
+    nodeId: row.node_id,
+    newData: row.new_data === null ? null : decodeTaggedValues(JSON.parse(row.new_data)),
+    oldData: row.old_data === null ? null : decodeTaggedValues(JSON.parse(row.old_data))
+  };
+}
+function rowToChangeEvent(row) {
+  return {
+    type: row.operation,
+    table: row.table_name,
+    row: row.new_data === null ? {} : decodeTaggedValues(JSON.parse(row.new_data)),
+    oldRow: row.old_data === null ? void 0 : decodeTaggedValues(JSON.parse(row.old_data)),
+    seq: BigInt(row.seq),
+    timestamp: row.changed_at,
+    rowId: row.row_id,
+    ...row.node_id !== "" ? { origin: row.node_id } : {},
+    ...row.hlc !== "" ? { hlc: row.hlc } : {},
+    ...row.tx_id !== "" ? { txId: row.tx_id } : {},
+    ...row.tx_end === 1 ? { txEnd: true } : {}
+  };
+}
+async function emitStagedEvents(conn, upToSeq, onChange) {
+  let cursor = 0n;
+  while (true) {
+    const rows = await selectStagedChangesInRange(conn, cursor, upToSeq, STAGED_APPLY_BATCH_ROWS);
+    if (rows.length === 0) return;
+    for (const row of rows) {
+      cursor = BigInt(row.seq);
+      try {
+        onChange(rowToChangeEvent(row));
+      } catch {
+      }
+    }
   }
 }
 
+// src/core/database-sync.ts
+var PUSHED_SEQ_META_KEY = "device_sync_pushed_seq";
+var PULL_SEQ_META_KEY = "device_sync_pull_seq";
+var PULL_EPOCH_META_KEY = "device_sync_pull_epoch";
+var RESYNC_REQUIRED_META_KEY = "device_sync_resync_required";
+var COLUMN_VERSIONS_SEQ_META_KEY = "device_sync_column_versions_seq";
+var DatabaseSyncController = class {
+  constructor(runExclusive, acquireWriter, cdc) {
+    this.runExclusive = runExclusive;
+    this.acquireWriter = acquireWriter;
+    this.cdc = cdc;
+  }
+  pkResolver = null;
+  tablesReady = false;
+  metaReady = false;
+  outboxReader = null;
+  localPruneBoundary = null;
+  snapshotGate = false;
+  defaultResolver = new LWWResolver();
+  applyChanges(batch, resolver) {
+    return this.runExclusive(async () => {
+      const applier = await this.ensureApplier();
+      const result = await applier.applyBatch(batch, resolver ?? this.defaultResolver);
+      if (result.droppedTables.length > 0) {
+        await this.cdc.changeTracker?.pruneDroppedTables(this.acquireWriter(), result.droppedTables);
+      }
+      return result;
+    });
+  }
+  devicePort() {
+    return {
+      identity: () => this.runExclusive(async () => ({ nodeId: (await this.cdc.ensureStamper()).nodeId })),
+      applyPulledTransaction: (changes, pullSeq, resolver) => this.applyPulledTransaction(changes, pullSeq, resolver),
+      stagePulledChanges: (events) => this.stagePulled(events),
+      applyStagedPull: (resolver, onChange) => this.applyStagedPull(resolver, onChange),
+      recoverStagedPull: (resolver, onChange) => this.recoverStagedPullState(resolver, onChange),
+      readOutboxBatch: (afterSeq, limit) => this.readOutboxBatch(afterSeq, limit),
+      countOutboxPending: (afterSeq) => this.countOutboxPending(afterSeq),
+      getPushCursor: () => this.getMetaSeq(PUSHED_SEQ_META_KEY).then((seq) => seq ?? 0n),
+      setPushCursor: (seq) => this.setMetaSeq(PUSHED_SEQ_META_KEY, seq),
+      getPullState: () => this.getPullState(),
+      getResyncRequired: () => this.getResyncRequired(),
+      setResyncRequired: (required) => this.setResyncRequired(required),
+      setPullState: (seq, epoch) => this.setPullState(seq, epoch),
+      protectUnpushedChanges: (pushedSeq) => {
+        this.localPruneBoundary = pushedSeq;
+        this.applyLocalPruneBoundary();
+      },
+      snapshotLoadPending: () => this.runExclusive(() => snapshotLoadPending(this.acquireWriter())),
+      beginSnapshotLoad: (tables) => this.beginSnapshotLoad(tables),
+      applySnapshotSchema: (schema) => this.runExclusive(() => applySnapshotSchema(this.acquireWriter(), schema)),
+      loadSnapshotPage: (table, rows) => this.runExclusive(() => loadSnapshotPage(this.acquireWriter(), table, rows)),
+      replaceMigrationHistory: (rows) => this.replaceMigrationHistory(rows),
+      endSnapshotLoad: (tables) => this.endSnapshotLoad(tables),
+      abortSnapshotLoad: () => this.runExclusive(() => abortSnapshotLoad(this.acquireWriter()))
+    };
+  }
+  get snapshotLoadBlocked() {
+    return this.snapshotGate;
+  }
+  seedSnapshotGate() {
+    this.snapshotGate = true;
+  }
+  applyPulledTransaction(changes, pullSeq, resolver) {
+    return this.runExclusive(async () => {
+      if (changes.length === 0) {
+        return { applied: 0, skipped: 0, conflicts: 0, droppedTables: [] };
+      }
+      await this.ensureMeta();
+      const applier = await this.ensureApplier();
+      let maxHlc = "";
+      let sourceNodeId = REMOTE_ORIGIN_NODE_ID;
+      for (const change of changes) {
+        if (change.hlc > maxHlc) maxHlc = change.hlc;
+        if (sourceNodeId === REMOTE_ORIGIN_NODE_ID && change.nodeId !== "") sourceNodeId = change.nodeId;
+      }
+      const result = await applier.applyGroup({
+        sourceNodeId,
+        txId: changes[0].txId,
+        changes,
+        resolver: resolver ?? this.defaultResolver,
+        withinTx: (tx) => upsertMetaValue(tx, PULL_SEQ_META_KEY, pullSeq.toString())
+      });
+      if (result.droppedTables.length > 0) {
+        await this.cdc.changeTracker?.pruneDroppedTables(this.acquireWriter(), result.droppedTables);
+      }
+      if (maxHlc !== "") {
+        await applier.mergeHlc(maxHlc);
+      }
+      return result;
+    });
+  }
+  stagePulled(events) {
+    return this.runExclusive(async () => {
+      await this.ensureMeta();
+      return stagePulledChanges(this.acquireWriter(), events);
+    });
+  }
+  applyStagedPull(resolver, onChange) {
+    return this.runExclusive(async () => {
+      await this.ensureMeta();
+      const applier = await this.ensureApplier();
+      return applyStagedTransactions(this.acquireWriter(), applier, this.stagedApplyOptions(resolver, onChange));
+    });
+  }
+  recoverStagedPullState(resolver, onChange) {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      const applier = await this.ensureApplier();
+      const recorded = await selectMetaValue(writer, PULL_SEQ_META_KEY);
+      const appliedFloor = recorded !== null && SEQ_STRING_RE.test(recorded) ? BigInt(recorded) : null;
+      return recoverStagedPull(writer, applier, appliedFloor, this.stagedApplyOptions(resolver, onChange));
+    });
+  }
+  stagedApplyOptions(resolver, onChange) {
+    return {
+      resolver: resolver ?? this.defaultResolver,
+      withinTx: (tx, appliedThroughSeq) => upsertMetaValue(tx, PULL_SEQ_META_KEY, appliedThroughSeq.toString()),
+      onChange
+    };
+  }
+  replaceMigrationHistory(rows) {
+    return this.runExclusive(async () => {
+      const writer = this.acquireWriter();
+      await replaceMigrationHistory(writer, rows);
+      await mirrorSchemaVersion(writer, highestMigrationVersion(rows));
+    });
+  }
+  async beginSnapshotLoad(tables) {
+    this.snapshotGate = true;
+    try {
+      await this.runExclusive(() => beginSnapshotLoad(this.acquireWriter(), tables, this.cdc.changeTracker));
+    } catch (err) {
+      this.snapshotGate = await this.runExclusive(() => snapshotLoadPending(this.acquireWriter()));
+      throw err;
+    }
+  }
+  async endSnapshotLoad(tables) {
+    await this.runExclusive(() => endSnapshotLoad(this.acquireWriter(), tables, this.cdc.changeTracker));
+    this.snapshotGate = false;
+  }
+  applyLocalPruneBoundary() {
+    if (this.localPruneBoundary !== null) {
+      this.cdc.changeTracker?.setPruneBoundary(this.localPruneBoundary);
+    }
+  }
+  readOutboxBatch(afterSeq, limit) {
+    return this.runExclusive(async () => {
+      this.applyLocalPruneBoundary();
+      const reader = await this.ensureOutboxReader();
+      return reader.readBatch(afterSeq, limit);
+    });
+  }
+  countOutboxPending(afterSeq) {
+    return this.runExclusive(async () => {
+      this.applyLocalPruneBoundary();
+      const writer = this.acquireWriter();
+      await this.ensureSyncTables(writer);
+      const stamper = await this.cdc.ensureStamper();
+      return selectCountOutboundChanges(writer, CHANGES_TABLE, afterSeq, stamper.nodeId);
+    });
+  }
+  getResyncRequired() {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      return await selectMetaValue(writer, RESYNC_REQUIRED_META_KEY) === "1";
+    });
+  }
+  setResyncRequired(required) {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      await upsertMetaValue(writer, RESYNC_REQUIRED_META_KEY, required ? "1" : "0");
+    });
+  }
+  getPullState() {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      const seq = await selectMetaValue(writer, PULL_SEQ_META_KEY);
+      if (seq === null || !SEQ_STRING_RE.test(seq)) return null;
+      const epoch = await selectMetaValue(writer, PULL_EPOCH_META_KEY);
+      return { seq: BigInt(seq), epoch: epoch ?? void 0 };
+    });
+  }
+  setPullState(seq, epoch) {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      await upsertMetaValue(writer, PULL_SEQ_META_KEY, seq.toString());
+      if (epoch !== void 0) {
+        await upsertMetaValue(writer, PULL_EPOCH_META_KEY, epoch);
+      }
+    });
+  }
+  getMetaSeq(key) {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      const value = await selectMetaValue(writer, key);
+      if (value === null || !SEQ_STRING_RE.test(value)) return null;
+      return BigInt(value);
+    });
+  }
+  setMetaSeq(key, seq) {
+    return this.runExclusive(async () => {
+      const writer = await this.ensureMeta();
+      await upsertMetaValue(writer, key, seq.toString());
+    });
+  }
+  async ensureMeta() {
+    const writer = this.acquireWriter();
+    if (!this.metaReady) {
+      await ensureMetaTable(writer);
+      this.metaReady = true;
+    }
+    return writer;
+  }
+  async ensureSyncTables(writer) {
+    if (!this.tablesReady) {
+      await ensureChangesTable(writer, CHANGES_TABLE);
+      await ensureBatchApplyTables(writer);
+      this.tablesReady = true;
+    }
+  }
+  async ensureOutboxReader() {
+    const writer = this.acquireWriter();
+    await this.ensureSyncTables(writer);
+    const stamper = await this.cdc.ensureStamper();
+    this.pkResolver ??= new PkResolver(writer);
+    this.outboxReader ??= new BatchReader(writer, stamper.nodeId, CHANGES_TABLE, this.pkResolver, true);
+    return this.outboxReader;
+  }
+  async ensureApplier() {
+    const writer = this.acquireWriter();
+    await this.ensureSyncTables(writer);
+    const stamper = await this.cdc.ensureStamper();
+    this.pkResolver ??= new PkResolver(writer);
+    return new BatchApplier(
+      writer,
+      stamper.nodeId,
+      stamper.hlc,
+      this.pkResolver,
+      (fromNodeId) => this.lastAppliedSeq(fromNodeId),
+      this.cdc.changeTracker ?? void 0,
+      CHANGES_TABLE,
+      (tx) => this.catchUpLocalColumnVersions(tx, stamper.nodeId)
+    );
+  }
+  async catchUpLocalColumnVersions(tx, localNodeId) {
+    const recorded = await selectMetaValue(tx, COLUMN_VERSIONS_SEQ_META_KEY);
+    const afterSeq = recorded !== null && SEQ_STRING_RE.test(recorded) ? BigInt(recorded) : 0n;
+    const latestSeq = await selectMaxChangeSeq(tx, CHANGES_TABLE);
+    if (latestSeq <= afterSeq) return;
+    await recordLocalColumnVersions(tx, CHANGES_TABLE, localNodeId, afterSeq);
+    await upsertMetaValue(tx, COLUMN_VERSIONS_SEQ_META_KEY, latestSeq.toString());
+  }
+  lastAppliedSeq(fromNodeId) {
+    return selectMaxAppliedSourceSeq(this.acquireWriter(), fromNodeId);
+  }
+};
+
 // src/core/group-committer.ts
 var DEFAULT_MAX_GROUP_SIZE = 1e3;
 var DML_PREFIX_RE = /^\s*(?:INSERT|UPDATE|DELETE|REPLACE)\b/i;
@@ -472,7 +1086,7 @@ var GroupCommitter = class {
   }
   async flush(batch) {
     const lone = batch[0];
-    if (batch.length === 1 && lone.statements.length === 1) {
+    if (batch.length === 1 && lone.statements.length === 1 && !this.needsStamp(lone.statements[0].sql)) {
       try {
         lone.resolve([await this.writerLock.run(() => this.runSingle(lone.statements[0]))]);
       } catch (err) {
@@ -489,21 +1103,52 @@ var GroupCommitter = class {
     }
     for (let i = 0; i < batch.length; i++) {
       const outcome = outcomes[i];
-      if (outcome.ok) batch[i].resolve(outcome.values);
+      if (outcome.ok) batch[i].resolve(outcome.values.slice(0, batch[i].statements.length));
       else batch[i].reject(outcome.error);
     }
   }
+  needsStamp(sql) {
+    if (!isGroupable(sql)) return false;
+    const stamps = this.hooks.stampStatements();
+    return stamps !== null && stamps.length > 0;
+  }
   async runSingle(statement) {
     const writer = this.hooks.acquireWriter();
-    const result = await execute(writer, statement.sql, statement.params);
+    const stamps = isGroupable(statement.sql) ? this.hooks.stampStatements() : null;
+    const result = stamps === null || stamps.length === 0 ? await execute(writer, statement.sql, statement.params) : await this.runStampedAlone(writer, statement, stamps);
     await this.hooks.afterCommit(writer, statement.sql);
     return result;
   }
+  async runStampedAlone(writer, statement, stamps) {
+    await writer.exec("SAVEPOINT sirannon_stamp");
+    try {
+      const result = await execute(writer, statement.sql, statement.params);
+      for (const stamp of stamps) {
+        await execute(writer, stamp.sql, stamp.params, stamp.trusted === true);
+      }
+      await writer.exec("RELEASE sirannon_stamp");
+      return result;
+    } catch (err) {
+      try {
+        await writer.exec("ROLLBACK TO sirannon_stamp");
+        await writer.exec("RELEASE sirannon_stamp");
+      } catch {
+      }
+      throw err;
+    }
+  }
   async runGroup(batch) {
     const writer = this.hooks.acquireWriter();
-    const units = batch.map((job) => ({
-      statements: job.statements.map((statement) => ({ sql: statement.sql, params: bindParams(statement.params) }))
-    }));
+    const units = batch.map((job, index) => {
+      const stamps = this.hooks.stampStatements({ persistClock: index === batch.length - 1 }) ?? [];
+      return {
+        statements: [...job.statements, ...stamps].map((statement) => ({
+          sql: statement.sql,
+          params: bindParams(statement.params),
+          ...statement.trusted === true ? { trusted: true } : {}
+        }))
+      };
+    });
     if (writer.runGroup) {
       const raw = await writer.runGroup(units);
       return raw.map(
@@ -589,38 +1234,1331 @@ var HookRegistry = class {
       this.hooks.set(event, [hook]);
     }
   }
-  loadConfig(config) {
-    for (const [configKey, event] of Object.entries(HOOK_CONFIG_MAP)) {
-      const value = config[configKey];
-      if (!value) continue;
-      const hooks = Array.isArray(value) ? value : [value];
-      for (const hook of hooks) {
-        this.addHook(event, hook);
-      }
+  loadConfig(config) {
+    for (const [configKey, event] of Object.entries(HOOK_CONFIG_MAP)) {
+      const value = config[configKey];
+      if (!value) continue;
+      const hooks = Array.isArray(value) ? value : [value];
+      for (const hook of hooks) {
+        this.addHook(event, hook);
+      }
+    }
+  }
+};
+
+// src/core/worker/config.ts
+var DEFAULT_MAX_PENDING_WRITES = 1024;
+var DEFAULT_RETRY_AFTER_MS = 1e3;
+function requireCount(value, name, min) {
+  if (!Number.isInteger(value) || value < min) {
+    throw new SirannonError(`writerWorker.${name} must be an integer >= ${min}`, "INVALID_WRITER_WORKER");
+  }
+  return value;
+}
+function resolveWriterWorkerConfig(option) {
+  if (!option) {
+    return { enabled: false, maxPendingWrites: 0, retryAfterMs: DEFAULT_RETRY_AFTER_MS, host: {} };
+  }
+  const opts = option === true ? {} : option;
+  const host = {};
+  if (opts.writeTimeoutMs !== void 0) host.writeTimeoutMs = requireCount(opts.writeTimeoutMs, "writeTimeoutMs", 0);
+  if (opts.maxRestarts !== void 0) host.maxRestarts = requireCount(opts.maxRestarts, "maxRestarts", 0);
+  const maxPendingWrites = opts.maxPendingWrites === void 0 ? DEFAULT_MAX_PENDING_WRITES : requireCount(opts.maxPendingWrites, "maxPendingWrites", 1);
+  return { enabled: true, maxPendingWrites, retryAfterMs: DEFAULT_RETRY_AFTER_MS, host };
+}
+
+// src/core/worker/gate.ts
+var WriteGate = class {
+  constructor(limit, retryAfterMs) {
+    this.limit = limit;
+    this.retryAfterMs = retryAfterMs;
+  }
+  inFlight = 0;
+  run(op) {
+    if (this.limit > 0 && this.inFlight >= this.limit) {
+      return Promise.reject(new WriteOverloadError(this.limit, this.retryAfterMs));
+    }
+    this.inFlight++;
+    return op().finally(() => {
+      this.inFlight--;
+    });
+  }
+};
+
+// src/core/writer-lock.ts
+var UNTRACKED = {
+  run: (operation) => operation(),
+  isActive: () => false,
+  exit: (operation) => operation()
+};
+var WriterLock = class {
+  tail = Promise.resolve();
+  context;
+  constructor(context) {
+    this.context = context ?? UNTRACKED;
+  }
+  run(operation) {
+    if (this.context.isActive()) {
+      return operation();
+    }
+    const enter = () => this.context.run(operation);
+    const ticket = this.tail.then(enter, enter);
+    this.tail = ticket.then(swallow, swallow);
+    return ticket;
+  }
+  isHeld() {
+    return this.context.isActive();
+  }
+  async settle() {
+    await this.run(() => Promise.resolve());
+  }
+  detached(operation) {
+    return this.context.exit(operation);
+  }
+};
+function swallow() {
+}
+
+// src/core/database-create.ts
+async function createDatabaseRuntime(id, path, driver, options, internals) {
+  const writerWorker = resolveWriterWorkerConfig(options?.writerWorker);
+  const readOnly = options?.readOnly ?? false;
+  if (writerWorker.enabled && !readOnly && !driver.startWriterHost) {
+    throw new SirannonError(
+      `writerWorker is enabled for database '${id}' but the driver does not carry a worker entry; use a driver that supports worker offload or disable writerWorker`,
+      "WRITER_WORKER_UNSUPPORTED"
+    );
+  }
+  const pool = await ConnectionPool.create({
+    driver,
+    path,
+    readOnly: options?.readOnly,
+    readPoolSize: options?.readPoolSize ?? 4,
+    walMode: options?.walMode ?? true,
+    synchronous: options?.synchronous,
+    useWriterWorker: writerWorker.enabled && !readOnly,
+    workerHostOptions: writerWorker.host
+  });
+  const writeGate = new WriteGate(writerWorker.enabled ? writerWorker.maxPendingWrites : 0, writerWorker.retryAfterMs);
+  const writerLock = new WriterLock(driver.createWriterContext?.());
+  const hookRegistry = new HookRegistry();
+  const observer = new DatabaseObserver(id, hookRegistry, internals?.parentHooks ?? null, internals?.metrics ?? null);
+  const backups = new DatabaseBackupController(
+    (op) => writerLock.run(op),
+    () => pool.acquireWriter(),
+    driver.createBackupEngine?.()
+  );
+  const canOpenSnapshotConnection = driver.capabilities.multipleConnections && path !== ":memory:";
+  const cdc = new DatabaseCdcController(
+    (op) => writerLock.run(op),
+    () => pool.acquireWriter(),
+    options?.cdcPollInterval ?? 50,
+    options?.cdcRetention ?? 36e5,
+    canOpenSnapshotConnection ? () => driver.open(path, { readonly: true, walMode: false }) : null
+  );
+  const sync = new DatabaseSyncController(
+    (op) => writeGate.run(() => writerLock.run(op)),
+    () => pool.acquireWriter(),
+    cdc
+  );
+  if (!readOnly && await snapshotLoadPending(pool.acquireWriter())) {
+    sync.seedSnapshotGate();
+  }
+  const groupCommitter = new GroupCommitter(writerLock, {
+    acquireWriter: () => pool.acquireWriter(),
+    afterCommit: (writer, sql) => applyDdlSideEffectsIfRelevant(cdc.changeTracker, writer, sql),
+    stampStatements: (stampOptions) => cdc.stampStatements(stampOptions)
+  });
+  return { pool, writeGate, writerLock, hookRegistry, observer, backups, cdc, sync, groupCommitter };
+}
+
+// src/core/database-reads.ts
+function readRows(deps, sql, params, options) {
+  return deps.observer.withQueryHooks(
+    sql,
+    params,
+    options,
+    () => onReadConnection(deps, sql, (conn) => query(conn, sql, params))
+  );
+}
+function readWireRows(deps, sql, params, options) {
+  return deps.observer.withQueryHooks(
+    sql,
+    params,
+    options,
+    () => onReadConnection(deps, sql, (conn) => queryForWire(conn, sql, params))
+  );
+}
+function readOneRow(deps, sql, params, options) {
+  return deps.observer.withQueryHooks(
+    sql,
+    params,
+    options,
+    () => onReadConnection(deps, sql, (conn) => queryOne(conn, sql, params))
+  );
+}
+function onReadConnection(deps, sql, op) {
+  if (deps.pool.readerCount === 0) {
+    return deps.writerLock.run(() => deps.observer.track(sql, () => op(deps.pool.acquireWriter())));
+  }
+  return deps.observer.track(sql, () => op(deps.pool.acquireReader()));
+}
+
+// src/core/extension-loader.ts
+async function loadExtension(driver, writer, extensionPath) {
+  if (!driver.capabilities.extensions || !driver.resolveExtensionPath) {
+    throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
+  }
+  if (!extensionPath || extensionPath.includes("\0")) {
+    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
+  }
+  for (let i = 0; i < extensionPath.length; i++) {
+    if (extensionPath.charCodeAt(i) <= 31) {
+      throw new ExtensionError(extensionPath, "Extension path contains control characters");
+    }
+  }
+  const segments = extensionPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
+  }
+  const resolved = driver.resolveExtensionPath(extensionPath);
+  try {
+    const escaped = resolved.replace(/'/g, "''");
+    await writer.exec(`SELECT load_extension('${escaped}')`);
+  } catch (err) {
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/core/live/column-collations.ts
+var TABLE_CONSTRAINT_STARTS = /* @__PURE__ */ new Set(["constraint", "primary", "unique", "check", "foreign"]);
+function parseColumnCollations(ddl) {
+  const collations = /* @__PURE__ */ new Map();
+  const tokens = tokenizeSql(ddl);
+  const open = tokens.findIndex((token) => token.kind === "punct" && token.value === "(" && token.depth === 0);
+  if (open === -1) return collations;
+  let definition = [];
+  for (let i = open + 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.depth === 0) break;
+    if (token.depth === 1 && token.kind === "punct" && token.value === ",") {
+      readDefinition(definition, collations);
+      definition = [];
+      continue;
+    }
+    definition.push(token);
+  }
+  readDefinition(definition, collations);
+  return collations;
+}
+function readDefinition(definition, collations) {
+  const name = definition[0];
+  if (name === void 0 || name.kind !== "word") return;
+  if (!name.quoted && TABLE_CONSTRAINT_STARTS.has(name.lower)) return;
+  for (let i = 1; i < definition.length - 1; i++) {
+    const token = definition[i];
+    if (token.kind === "word" && !token.quoted && token.lower === "collate") {
+      collations.set(name.value, definition[i + 1].value);
+      return;
+    }
+  }
+}
+
+// src/core/live/sqlite-order.ts
+var TYPE_NULL = 0;
+var TYPE_NUMBER = 1;
+var TYPE_TEXT = 2;
+var TYPE_BLOB = 3;
+var encoder = new TextEncoder();
+function resolveCollation(name) {
+  if (name === null) return "binary";
+  const lower = name.toLowerCase();
+  if (lower === "binary" || lower === "nocase" || lower === "rtrim") return lower;
+  throw new CDCError(
+    `Cannot keep a live query ordered by the '${name}' collation: order is maintained for BINARY, NOCASE, and RTRIM`
+  );
+}
+function toSortValue(value, collation) {
+  if (value === null || value === void 0) return { type: TYPE_NULL };
+  if (typeof value === "number" || typeof value === "bigint") return { type: TYPE_NUMBER, numeric: value };
+  if (typeof value === "boolean") return { type: TYPE_NUMBER, numeric: value ? 1 : 0 };
+  if (typeof value === "string") return { type: TYPE_TEXT, bytes: encoder.encode(applyCollation(value, collation)) };
+  if (value instanceof Uint8Array) return { type: TYPE_BLOB, bytes: value };
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    return { type: TYPE_BLOB, bytes: new Uint8Array(view.buffer, view.byteOffset, view.byteLength) };
+  }
+  return { type: TYPE_TEXT, bytes: encoder.encode(applyCollation(String(value), collation)) };
+}
+function applyCollation(text, collation) {
+  if (collation === "nocase") return upperAscii(text);
+  if (collation === "rtrim") return trimTrailingSpaces(text);
+  return text;
+}
+function upperAscii(text) {
+  let result = "";
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    result += code >= 97 && code <= 122 ? String.fromCharCode(code - 32) : text[i];
+  }
+  return result;
+}
+function trimTrailingSpaces(text) {
+  let end = text.length;
+  while (end > 0 && text.charCodeAt(end - 1) === 32) end--;
+  return text.slice(0, end);
+}
+function compareSortValues(left, right) {
+  if (left.type !== right.type) return left.type < right.type ? -1 : 1;
+  if (left.type === TYPE_NULL) return 0;
+  if (left.type === TYPE_NUMBER) return compareNumeric(left.numeric, right.numeric);
+  return compareBytes(left.bytes, right.bytes);
+}
+function compareNumeric(left, right) {
+  if (typeof left === "number" && typeof right === "number") {
+    return left < right ? -1 : left > right ? 1 : 0;
+  }
+  if (typeof left === "bigint" && typeof right === "bigint") {
+    return left < right ? -1 : left > right ? 1 : 0;
+  }
+  const big = typeof left === "bigint" ? left : right;
+  const real = typeof left === "bigint" ? right : left;
+  const sign = typeof left === "bigint" ? 1 : -1;
+  if (!Number.isFinite(real)) return real > 0 ? -sign : sign;
+  const whole = Math.floor(real);
+  const wholeAsBig = BigInt(whole);
+  if (big !== wholeAsBig) return big < wholeAsBig ? -sign : sign;
+  return real > whole ? -sign : 0;
+}
+function compareBytes(left, right) {
+  const shared = Math.min(left.length, right.length);
+  for (let i = 0; i < shared; i++) {
+    if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
+  }
+  return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+}
+function buildSortKeyPlan(terms) {
+  const collations = terms.map((term) => resolveCollation(term.collation));
+  const descending = terms.map((term) => term.direction === "desc");
+  const nullsLast = terms.map((term) => term.nulls === "last");
+  return {
+    collations,
+    compare(left, right) {
+      for (let i = 0; i < terms.length; i++) {
+        const a = left[i];
+        const b = right[i];
+        const aNull = a.type === TYPE_NULL;
+        const bNull = b.type === TYPE_NULL;
+        if (aNull !== bNull) return (aNull ? 1 : -1) * (nullsLast[i] ? 1 : -1);
+        if (aNull) continue;
+        const order = compareSortValues(a, b);
+        if (order !== 0) return descending[i] ? -order : order;
+      }
+      return 0;
+    }
+  };
+}
+function lowerBoundIndex(rows, key, plan) {
+  let low = 0;
+  let high = rows.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (plan.compare(rows[middle].sort, key) < 0) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function placementIndex(rows, key, plan) {
+  let low = 0;
+  let high = rows.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (plan.compare(rows[middle].sort, key) <= 0) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+
+// src/core/live/live-result.ts
+var LiveResult = class {
+  constructor(plan) {
+    this.plan = plan;
+  }
+  rows = [];
+  index = /* @__PURE__ */ new Map();
+  windowTruncated = false;
+  get size() {
+    return this.rows.length;
+  }
+  snapshot() {
+    return this.rows.map((held) => held.row);
+  }
+  reset(rows) {
+    this.rows = rows;
+    this.index = new Map(rows.map((held) => [held.key, held]));
+    this.windowTruncated = this.plan.limit !== null && rows.length >= this.plan.limit;
+  }
+  apply(changes) {
+    const draft = new Draft(this.plan, this.rows.slice(), new Map(this.index), this.windowTruncated);
+    for (const change of changes) {
+      if (!draft.apply(change)) return null;
+    }
+    if (!draft.windowIsWhole()) return null;
+    this.rows = draft.rows;
+    this.index = draft.index;
+    this.windowTruncated = draft.truncated;
+    return draft.ops;
+  }
+};
+var Draft = class {
+  constructor(plan, rows, index, truncated) {
+    this.plan = plan;
+    this.rows = rows;
+    this.index = index;
+    this.truncated = truncated;
+  }
+  ops = [];
+  apply(change) {
+    const held = this.index.get(change.key);
+    if (change.after === null) {
+      if (change.before === null) return true;
+      return held === void 0 ? this.plan.offset === 0 : this.remove(held);
+    }
+    const entering = { key: change.key, row: change.after.row, sort: change.after.sort };
+    if (held !== void 0) {
+      if (this.plan.sortPlan.compare(held.sort, entering.sort) === 0) return this.replace(held, entering);
+      if (!this.remove(held)) return false;
+    } else if (change.before !== null && this.plan.offset > 0) {
+      return false;
+    }
+    return this.insert(entering);
+  }
+  windowIsWhole() {
+    if (this.plan.limit === null || !this.truncated) return true;
+    return this.rows.length >= this.plan.limit;
+  }
+  replace(held, replacement) {
+    const at = this.locate(held);
+    if (at === -1) return false;
+    this.rows[at] = replacement;
+    this.index.set(replacement.key, replacement);
+    this.ops.push({ op: "update", index: at, row: replacement.row });
+    return true;
+  }
+  remove(held) {
+    if (this.plan.offset > 0) return false;
+    const at = this.locate(held);
+    if (at === -1) return false;
+    this.rows.splice(at, 1);
+    this.index.delete(held.key);
+    this.ops.push({ op: "delete", index: at });
+    return true;
+  }
+  insert(held) {
+    if (this.plan.offset > 0) {
+      if (this.rows.length === 0) return false;
+      if (this.plan.sortPlan.compare(held.sort, this.rows[0].sort) <= 0) return false;
+    }
+    const at = placementIndex(this.rows, held.sort, this.plan.sortPlan);
+    if (this.plan.limit !== null && at >= this.plan.limit) {
+      this.truncated = true;
+      return true;
+    }
+    this.rows.splice(at, 0, held);
+    this.index.set(held.key, held);
+    this.ops.push({ op: "insert", index: at, row: held.row });
+    if (this.plan.limit !== null && this.rows.length > this.plan.limit) {
+      const dropped = this.rows.pop();
+      if (dropped !== void 0) this.index.delete(dropped.key);
+      this.ops.push({ op: "delete", index: this.rows.length });
+      this.truncated = true;
+    }
+    return true;
+  }
+  locate(held) {
+    let at = lowerBoundIndex(this.rows, held.sort, this.plan.sortPlan);
+    while (at < this.rows.length && this.rows[at].key !== held.key) {
+      if (this.plan.sortPlan.compare(this.rows[at].sort, held.sort) !== 0) return -1;
+      at++;
+    }
+    return at < this.rows.length ? at : -1;
+  }
+};
+
+// src/core/live/row-keys.ts
+var HEX = "0123456789abcdef";
+function rowidKey(value) {
+  return `rowid:${String(value)}`;
+}
+function encodeRowKey(values) {
+  let key = "";
+  for (const value of values) {
+    const part = encodePart(value);
+    key += `${part.length}:${part}`;
+  }
+  return key;
+}
+function encodePart(value) {
+  if (value === null || value === void 0) return "z";
+  if (typeof value === "bigint") return `n${value.toString()}`;
+  if (typeof value === "number") return `n${Number.isInteger(value) ? value.toFixed(0) : value.toString()}`;
+  if (typeof value === "boolean") return `n${value ? "1" : "0"}`;
+  if (typeof value === "string") return `s${value}`;
+  if (value instanceof Uint8Array) return `b${toHex2(value)}`;
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    return `b${toHex2(new Uint8Array(view.buffer, view.byteOffset, view.byteLength))}`;
+  }
+  return `s${String(value)}`;
+}
+function toHex2(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += HEX[byte >> 4] + HEX[byte & 15];
+  }
+  return hex;
+}
+
+// src/core/live/live-query.ts
+var MaintainedLiveQuery = class _MaintainedLiveQuery {
+  constructor(source) {
+    this.source = source;
+    this.result = new LiveResult(source.plan);
+  }
+  state = { status: "pending" };
+  listeners = /* @__PURE__ */ new Set();
+  result;
+  batches = [];
+  pending = [];
+  pendingBytes = 0;
+  pendingOverflowed = false;
+  stopDelivery = null;
+  appliedThroughSeq = -1n;
+  reading = false;
+  readAgain = false;
+  draining = false;
+  closed = false;
+  static async open(source) {
+    const query2 = new _MaintainedLiveQuery(source);
+    try {
+      await query2.refresh(false);
+    } catch (err) {
+      await query2.close();
+      throw err;
+    }
+    if (query2.state.status === "error") {
+      const failure = query2.state.error;
+      await query2.close();
+      throw failure;
+    }
+    return query2;
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stopDelivery?.();
+    this.stopDelivery = null;
+    this.listeners.clear();
+    this.batches.length = 0;
+    this.pending = [];
+    await this.source.release();
+  }
+  receive(event) {
+    if (this.closed) return;
+    if (event.seq <= this.appliedThroughSeq) return;
+    if (!this.pendingOverflowed) {
+      this.pending.push(event);
+      this.pendingBytes += approximateBytes(event);
+      if (this.pending.length > this.source.maxTransactionChanges || this.pendingBytes > this.source.maxTransactionBytes) {
+        this.pendingOverflowed = true;
+        this.pending = [];
+      }
+    }
+    if (event.txEnd !== true) return;
+    const overflowed = this.pendingOverflowed;
+    const batch = this.pending;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.pendingOverflowed = false;
+    this.batches.push(overflowed ? [] : batch);
+    void this.drain();
+  }
+  deliveryLost() {
+    if (this.closed) return;
+    this.stopDelivery = null;
+    this.batches.length = 0;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.pendingOverflowed = false;
+    void this.reread();
+  }
+  async drain() {
+    if (this.draining || this.reading || this.closed) return;
+    this.draining = true;
+    try {
+      while (this.batches.length > 0 && !this.closed && !this.reading) {
+        const batch = this.batches.shift();
+        if (batch === void 0) break;
+        await this.applyBatch(batch);
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  async applyBatch(batch) {
+    if (batch.length === 0) {
+      await this.reread();
+      return;
+    }
+    const fresh = batch.filter((event) => event.seq > this.appliedThroughSeq);
+    if (fresh.length === 0) return;
+    let changes;
+    try {
+      changes = await this.evaluate(fresh);
+    } catch (err) {
+      this.fail(err);
+      return;
+    }
+    if (this.closed) return;
+    const highest = fresh[fresh.length - 1].seq;
+    if (changes.length === 0) {
+      this.appliedThroughSeq = highest;
+      return;
+    }
+    const ops = changes.length > this.result.size ? null : this.result.apply(changes);
+    if (ops === null) {
+      await this.reread();
+      return;
+    }
+    this.appliedThroughSeq = highest;
+    this.publish({ status: "ready", rows: this.result.snapshot(), revalidating: false }, { kind: "ops", ops });
+  }
+  async evaluate(events) {
+    const candidates = [];
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      if (event.type !== "insert" && event.oldRow !== void 0) {
+        candidates.push({ slot: i * 2, payload: event.oldRow });
+      }
+      if (event.type !== "delete") {
+        candidates.push({ slot: i * 2 + 1, payload: event.row });
+      }
+    }
+    const matches = await this.source.probe.evaluate(candidates);
+    const changes = [];
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      const before = matches.get(i * 2) ?? null;
+      const after = matches.get(i * 2 + 1) ?? null;
+      if (before === null && after === null) continue;
+      const beforeKey = event.oldRow === void 0 ? null : this.keyOf(event, event.oldRow);
+      const afterKey = event.type === "delete" ? null : this.keyOf(event, event.row);
+      if (before !== null && after !== null && beforeKey !== null && afterKey !== null && beforeKey !== afterKey) {
+        changes.push({ key: beforeKey, before, after: null });
+        changes.push({ key: afterKey, before: null, after });
+        continue;
+      }
+      const key = after !== null ? afterKey ?? beforeKey : beforeKey;
+      if (key === null) continue;
+      changes.push({ key, before, after });
+    }
+    return changes;
+  }
+  keyOf(event, payload) {
+    if (this.source.plan.usesRowid) return event.rowId === void 0 ? null : rowidKey(event.rowId);
+    return encodeRowKey(this.source.plan.keyColumns.map((column) => payload[column]));
+  }
+  async reread() {
+    if (this.reading) {
+      this.readAgain = true;
+      return;
+    }
+    if (this.state.status === "ready" && !this.state.revalidating) {
+      this.publish({ status: "ready", rows: this.state.rows, revalidating: true }, { kind: "revalidating" });
+    }
+    await this.refresh(true);
+  }
+  async refresh(spread) {
+    this.reading = true;
+    try {
+      do {
+        this.readAgain = false;
+        if (spread && this.source.rereadJitterMs > 0) {
+          await this.source.wait(Math.floor(Math.random() * this.source.rereadJitterMs));
+        }
+        if (this.closed) return;
+        const refreshed = await this.source.read();
+        if (this.closed) return;
+        this.result.reset(refreshed.rows);
+        this.appliedThroughSeq = refreshed.seq;
+        if (this.stopDelivery === null) {
+          const stop = await this.source.start(
+            { onEvent: (event) => this.receive(event), onLost: () => this.deliveryLost() },
+            refreshed.seq
+          );
+          if (this.closed) {
+            stop();
+            return;
+          }
+          this.stopDelivery = stop;
+        }
+      } while (this.readAgain && !this.closed);
+      this.publish({ status: "ready", rows: this.result.snapshot(), revalidating: false }, { kind: "rows" });
+    } catch (err) {
+      this.fail(err);
+    } finally {
+      this.reading = false;
+    }
+    if (!this.closed && this.batches.length > 0) void this.drain();
+  }
+  fail(err) {
+    if (this.closed) return;
+    this.publish({ status: "error", error: err instanceof Error ? err : new Error(String(err)) }, { kind: "error" });
+  }
+  publish(next, update) {
+    this.state = next;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(update);
+      } catch {
+      }
+    }
+  }
+};
+function approximateBytes(event) {
+  return approximateRowBytes(event.row) + (event.oldRow === void 0 ? 0 : approximateRowBytes(event.oldRow));
+}
+function approximateRowBytes(row) {
+  let bytes = 0;
+  for (const key of Object.keys(row)) {
+    const value = row[key];
+    bytes += key.length + 8;
+    if (typeof value === "string") bytes += value.length;
+    else if (value instanceof Uint8Array) bytes += value.byteLength;
+  }
+  return bytes;
+}
+
+// src/core/live/primed-delivery.ts
+var PrimedLiveDelivery = class {
+  constructor(cdc, conn, run, table) {
+    this.cdc = cdc;
+    this.conn = conn;
+    this.run = run;
+    this.table = table;
+  }
+  async start(handlers, sinceSeq) {
+    const tracker = this.cdc.changeTracker;
+    const manager = this.cdc.subscriptions;
+    if (tracker === null || manager === null) {
+      throw new CDCError(`Cannot deliver changes for '${this.table}': the table is not watched`);
+    }
+    const grouper = new TransactionGrouper((event) => {
+      handlers.onEvent(event);
+      return true;
+    });
+    let stopped = false;
+    let removeBatchEnd = () => {
+    };
+    let subscription = null;
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      removeBatchEnd();
+      subscription?.unsubscribe();
+    };
+    const primed = new PrimedSubscription(
+      sinceSeq,
+      (event) => {
+        grouper.receive(event);
+        return true;
+      },
+      () => {
+        stop();
+        handlers.onLost();
+      }
+    );
+    const boundary = tracker.cursor;
+    const boundaryEndsTransaction = tracker.pollEndedAtTxBoundary;
+    subscription = manager.subscribe(this.table, void 0, (event) => primed.onLiveEvent(event));
+    try {
+      await this.run(() => primed.replayTables(tracker, this.conn, [this.table], void 0, boundary));
+    } catch (err) {
+      stop();
+      throw err;
+    }
+    if (stopped) return stop;
+    grouper.flush(boundaryEndsTransaction);
+    primed.goLive();
+    removeBatchEnd = manager.addBatchEndListener((atTxBoundary) => {
+      grouper.flush(atTxBoundary);
+    });
+    return stop;
+  }
+};
+
+// src/core/system-catalog/live-probe-table.ts
+var SAFE_DECLARED_TYPE = /^[A-Za-z0-9_ ()',.+-]*$/;
+async function ensureLiveProbeTable(conn, probeTable, columns) {
+  assertSafeIdentifier(probeTable);
+  if (columns.length === 0) {
+    throw new SirannonError(`Cannot stage rows for '${probeTable}': the table declares no columns`, "CDC_ERROR");
+  }
+  const definitions = columns.map((column) => {
+    assertSafeIdentifier(column.name);
+    if (!SAFE_DECLARED_TYPE.test(column.type)) {
+      throw new SirannonError(`Unsafe column type for internal schema: ${column.type}`, "INTERNAL_SCHEMA_ERROR");
+    }
+    if (column.collation !== null) assertSafeIdentifier(column.collation);
+    const type = column.type.trim().length === 0 ? "" : ` ${column.type.trim()}`;
+    const collate = column.collation === null ? "" : ` COLLATE "${column.collation}"`;
+    return `"${column.name}"${type}${collate}`;
+  });
+  await conn.exec(`CREATE TEMP TABLE IF NOT EXISTS "${probeTable}" (${definitions.join(", ")})`);
+}
+async function dropLiveProbeTable(conn, probeTable) {
+  assertSafeIdentifier(probeTable);
+  await conn.exec(`DROP TABLE IF EXISTS temp."${probeTable}"`);
+}
+async function prepareInsertLiveProbeRow(conn, probeTable, columns) {
+  assertSafeIdentifier(probeTable);
+  const names = columns.map((column) => {
+    assertSafeIdentifier(column.name);
+    return `"${column.name}"`;
+  });
+  const placeholders = new Array(columns.length + 1).fill("?").join(", ");
+  return conn.prepare(`INSERT INTO temp."${probeTable}" (rowid, ${names.join(", ")}) VALUES (${placeholders})`);
+}
+async function prepareDeleteLiveProbeRows(conn, probeTable) {
+  assertSafeIdentifier(probeTable);
+  return conn.prepare(`DELETE FROM temp."${probeTable}"`);
+}
+function selectLiveProbeMatchesSql(probeTable, keyColumn, projection, where, sourceName) {
+  assertSafeIdentifier(probeTable);
+  assertSafeIdentifier(keyColumn);
+  const filter = where === null ? "" : `
+WHERE (${where}
+)`;
+  return `SELECT rowid AS "${keyColumn}"
+, ${projection}
+FROM temp."${probeTable}" AS "${sourceName}"${filter}`;
+}
+
+// src/core/live/query-plan.ts
+var KEY_COLUMN = "_sirannon_k";
+var SORT_COLUMN_PREFIX = "_sirannon_s";
+var IDENTIFIER_RE2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function buildLivePlan(shape, table, params) {
+  const sourceName = shape.alias ?? shape.table;
+  assertIdentifier(shape, sourceName, "the table or its alias");
+  for (const column of table.columns) {
+    if (column.name.toLowerCase().startsWith(INTERNAL_TABLE_PREFIX)) {
+      throw new CDCError(
+        `Cannot open a live query for '${shape.sql}': column '${column.name}' uses the '${INTERNAL_TABLE_PREFIX}' prefix Sirannon reserves`
+      );
+    }
+  }
+  const usesRowid = table.pkColumns.length === 0;
+  const keyColumns = usesRowid ? ["rowid"] : table.pkColumns;
+  const keyColumnAliases = keyColumns.map((_, index) => `${KEY_COLUMN}${index}`);
+  const sortColumns = shape.sortTerms.map((_, index) => `${SORT_COLUMN_PREFIX}${index}`);
+  const sortExpressions = shape.sortTerms.map((term) => resolveSortExpression(shape, term));
+  const collations = shape.sortTerms.map(
+    (term, index) => effectiveCollation(term, sortExpressions[index], sourceName, table.collations)
+  );
+  const sortPlan = buildSortKeyPlan(shape.sortTerms.map((term, index) => ({ ...term, collation: collations[index] })));
+  const projection = [
+    shape.selectList,
+    ...sortExpressions.map((expression, index) => `${expression} AS "${sortColumns[index]}"`)
+  ].join("\n, ");
+  const keyProjection = keyColumns.map((column, index) => `"${sourceName}"."${column}" AS "${keyColumnAliases[index]}"`).join(", ");
+  const from = shape.alias === null ? `"${shape.table}"` : `"${shape.table}" AS "${shape.alias}"`;
+  const where = shape.where === null ? "" : `
+WHERE (${shape.where}
+)`;
+  const tail = shape.tail.length === 0 ? "" : `
+${shape.tail}`;
+  return {
+    shape,
+    sourceName,
+    probeColumns: table.columns.map((column) => ({
+      name: column.name,
+      type: column.type,
+      collation: table.collations.get(column.name) ?? null
+    })),
+    keyColumns,
+    usesRowid,
+    sortPlan,
+    sortColumns,
+    keyColumnAliases,
+    readSql: `SELECT ${projection}
+, ${keyProjection}
+FROM ${from}${where}${tail}`,
+    probeSql: (probeTable) => selectLiveProbeMatchesSql(probeTable, KEY_COLUMN, projection, shape.where, sourceName),
+    probeParams: (bound) => sliceProbeParams(shape, bound),
+    limit: shape.limit === null ? null : resolveBound(shape, shape.limit, params, "LIMIT"),
+    offset: shape.offset === null ? 0 : resolveBound(shape, shape.offset, params, "OFFSET")
+  };
+}
+function sliceProbeParams(shape, params) {
+  if (params === void 0) return [];
+  if (!Array.isArray(params)) return [params];
+  return params.slice(0, shape.selectParameters + shape.whereParameters);
+}
+function probeNamedParams(probeSql, params) {
+  if (params === void 0 || Array.isArray(params)) return params;
+  const used = /* @__PURE__ */ new Set();
+  for (const token of tokenizeSql(probeSql)) {
+    const name = parameterName(token);
+    if (name !== null) used.add(name);
+  }
+  const picked = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (used.has(key)) picked[key] = value;
+  }
+  return picked;
+}
+function resolveSortExpression(shape, term) {
+  const tokens = tokenizeSql(term.expression);
+  if (tokens.length === 1 && tokens[0].kind === "number") {
+    return resolveOrdinal(shape, Number(tokens[0].value));
+  }
+  if (tokens.length === 1 && tokens[0].kind === "word") {
+    const item = shape.selectItems.find((candidate) => candidate.alias === tokens[0].value);
+    if (item !== void 0) return item.expression;
+  }
+  return term.expression;
+}
+function resolveOrdinal(shape, ordinal) {
+  if (shape.selectItems.some((item2) => item2.star)) {
+    throw new CDCError(
+      `Cannot open a live query for '${shape.sql}': ORDER BY ${ordinal} cannot be resolved through '*', so name the column instead`
+    );
+  }
+  const item = shape.selectItems[ordinal - 1];
+  if (item === void 0) {
+    throw new CDCError(
+      `Cannot open a live query for '${shape.sql}': ORDER BY ${ordinal} names no column of the select list`
+    );
+  }
+  return item.expression;
+}
+function effectiveCollation(term, expression, sourceName, collations) {
+  if (term.collation !== null) return term.collation;
+  const column = bareColumnReference(expression, sourceName);
+  return column === null ? null : collations.get(column) ?? null;
+}
+function bareColumnReference(expression, sourceName) {
+  const tokens = tokenizeSql(expression);
+  if (tokens.length === 1 && tokens[0].kind === "word") return tokens[0].value;
+  if (tokens.length === 3 && tokens[0].kind === "word" && tokens[1].value === "." && tokens[2].kind === "word") {
+    return tokens[0].value === sourceName ? tokens[2].value : null;
+  }
+  return null;
+}
+function resolveBound(shape, bound, params, label) {
+  if (bound.kind === "literal") return bound.literal;
+  const value = boundParameterValue(bound, params, shape);
+  if (typeof value === "bigint") return assertWholeBound(shape, Number(value), label);
+  if (typeof value === "number") return assertWholeBound(shape, value, label);
+  throw new CDCError(`Cannot open a live query for '${shape.sql}': ${label} is bound to a value that is not a number`);
+}
+function boundParameterValue(bound, params, shape) {
+  if (params === void 0) {
+    throw new CDCError(`Cannot open a live query for '${shape.sql}': ${bound.parameter} has no bound value`);
+  }
+  if (!Array.isArray(params)) return params[bound.parameter.slice(1)];
+  const numbered = bound.parameter.length > 1 ? Number(bound.parameter.slice(1)) : 0;
+  const ordinal = numbered > 0 ? numbered : placeholderOrdinal(shape.sql, bound.position);
+  return params[ordinal - 1];
+}
+function placeholderOrdinal(sql, position) {
+  let ordinal = 0;
+  for (const token of tokenizeSql(sql)) {
+    if (token.kind !== "param") continue;
+    ordinal++;
+    if (token.start === position) return ordinal;
+  }
+  return ordinal;
+}
+function assertWholeBound(shape, value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new CDCError(
+      `Cannot open a live query for '${shape.sql}': ${label} is bound to ${value}, and it takes a non-negative whole number`
+    );
+  }
+  return value;
+}
+function assertIdentifier(shape, name, label) {
+  if (!IDENTIFIER_RE2.test(name)) {
+    throw new CDCError(
+      `Cannot open a live query for '${shape.sql}': ${label} must contain only letters, digits, and underscores, and start with a letter or underscore`
+    );
+  }
+}
+
+// src/core/live/row-probe.ts
+var RowProbe = class _RowProbe {
+  constructor(conn, probeTable, plan, run, insert, clear, match, matchParams) {
+    this.conn = conn;
+    this.probeTable = probeTable;
+    this.plan = plan;
+    this.run = run;
+    this.insert = insert;
+    this.clear = clear;
+    this.match = match;
+    this.matchParams = matchParams;
+  }
+  closed = false;
+  static async open(conn, probeTable, plan, params, run) {
+    const sql = plan.probeSql(probeTable);
+    try {
+      return await run(async () => {
+        await ensureLiveProbeTable(conn, probeTable, plan.probeColumns);
+        const insert = await prepareInsertLiveProbeRow(conn, probeTable, plan.probeColumns);
+        const clear = await prepareDeleteLiveProbeRows(conn, probeTable);
+        const match = await conn.prepare(sql);
+        const named = probeNamedParams(sql, params);
+        const matchParams = named === void 0 || Array.isArray(named) ? plan.probeParams(params) : [named];
+        return new _RowProbe(conn, probeTable, plan, run, insert, clear, match, matchParams);
+      });
+    } catch (err) {
+      await run(() => dropLiveProbeTable(conn, probeTable)).catch(() => {
+      });
+      throw err;
+    }
+  }
+  async evaluate(candidates) {
+    const matches = /* @__PURE__ */ new Map();
+    if (candidates.length === 0 || this.closed) return matches;
+    await this.run(async () => {
+      try {
+        for (const candidate of candidates) {
+          const values = this.plan.probeColumns.map((column) => candidate.payload[column.name] ?? null);
+          await this.insert.run(candidate.slot, ...values);
+        }
+        const rows = await this.match.all(...this.matchParams);
+        for (const row of rows) {
+          matches.set(Number(row[KEY_COLUMN]), this.take(row));
+        }
+      } finally {
+        await this.clear.run();
+      }
+    });
+    return matches;
+  }
+  take(row) {
+    const sort = this.plan.sortColumns.map(
+      (column, index) => toSortValue(row[column], this.plan.sortPlan.collations[index])
+    );
+    delete row[KEY_COLUMN];
+    for (const column of this.plan.sortColumns) delete row[column];
+    return { row, sort };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      await this.run(() => dropLiveProbeTable(this.conn, this.probeTable));
+    } catch {
+    }
+  }
+};
+
+// src/core/live/statement-shape.ts
+var UNSUPPORTED_WORDS = /* @__PURE__ */ new Map([
+  ["union", "a compound SELECT"],
+  ["intersect", "a compound SELECT"],
+  ["except", "a compound SELECT"],
+  ["group", "GROUP BY"],
+  ["having", "HAVING"],
+  ["window", "a window clause"],
+  ["join", "a join"],
+  ["natural", "a join"],
+  ["cross", "a join"],
+  ["inner", "a join"],
+  ["outer", "a join"],
+  ["left", "a join"],
+  ["right", "a join"],
+  ["full", "a join"],
+  ["with", "a common table expression"],
+  ["values", "a VALUES clause"],
+  ["distinct", "DISTINCT"]
+]);
+var CLOCK_KEYWORDS = /* @__PURE__ */ new Set(["current_date", "current_time", "current_timestamp"]);
+var VOLATILE_FUNCTIONS = /* @__PURE__ */ new Set(["random", "randomblob", "changes", "last_insert_rowid", "total_changes"]);
+var CLOCK_FUNCTIONS = /* @__PURE__ */ new Set(["date", "time", "datetime", "julianday", "unixepoch", "strftime", "timediff"]);
+var CLOCK_MODIFIER = /\b(now|localtime)\b/i;
+var AGGREGATE_FUNCTIONS = /* @__PURE__ */ new Set([
+  "avg",
+  "count",
+  "group_concat",
+  "json_group_array",
+  "json_group_object",
+  "max",
+  "min",
+  "string_agg",
+  "sum",
+  "total"
+]);
+function analyseStatement(sql) {
+  assertSqlAllowed(sql);
+  const tokens = tokenizeSql(sql);
+  if (tokens.length === 0 || tokens[0].lower !== "select" || tokens[0].quoted) {
+    throw unsupported(sql, "a live query reads with a single SELECT statement");
+  }
+  const body = withoutTrailingSemicolon(tokens);
+  assertSupportedWords(sql, body);
+  assertDeterministic(sql, body);
+  const clauses = findClauses(sql, body);
+  const source = readSource(sql, body, clauses);
+  const sortTerms = readSortTerms(sql, body, clauses);
+  const window = readWindow(sql, body, clauses);
+  if (window.limit !== null && sortTerms.length === 0) {
+    throw unsupported(sql, "a live query with LIMIT orders its rows, otherwise the window has no defined membership");
+  }
+  const usesPositionalParameters = body.some((token) => token.kind === "param" && token.value.startsWith("?"));
+  assertSortTermsBindByName(sql, sortTerms, usesPositionalParameters);
+  return {
+    sql,
+    table: source.table,
+    alias: source.alias,
+    selectList: sql.slice(clauses.selectStart, clauses.fromKeyword).trim(),
+    selectItems: readSelectItems(sql, body, clauses),
+    where: readWhere(sql, clauses),
+    sortTerms,
+    limit: window.limit,
+    offset: window.offset,
+    tail: sql.slice(clauses.tailStart, clauses.statementEnd).trim(),
+    selectParameters: countParameters(body, clauses.selectStart, clauses.fromKeyword),
+    whereParameters: clauses.whereStart === null || clauses.whereEnd === null ? 0 : countParameters(body, clauses.whereStart, clauses.whereEnd),
+    usesPositionalParameters
+  };
+}
+function countParameters(body, start, end) {
+  return body.filter((token) => token.kind === "param" && token.start >= start && token.end <= end).length;
+}
+function readWhere(sql, clauses) {
+  if (clauses.whereStart === null || clauses.whereEnd === null) return null;
+  return sql.slice(clauses.whereStart, clauses.whereEnd).trim();
+}
+function assertSortTermsBindByName(sql, sortTerms, positional) {
+  if (!positional) return;
+  for (const term of sortTerms) {
+    if (tokenizeSql(term.expression).some((token) => token.kind === "param")) {
+      throw unsupported(
+        sql,
+        "a live query binds an ORDER BY parameter by name, because it evaluates the term a second time to place a changed row"
+      );
+    }
+  }
+}
+function assertSupportedWords(sql, body) {
+  for (let i = 0; i < body.length; i++) {
+    const token = body[i];
+    if (token.kind !== "word" || token.quoted) continue;
+    if (i > 0 && token.lower === "select") {
+      throw unsupported(sql, "a subquery in a live query is not maintainable");
+    }
+    if (token.lower === "over" && body[i + 1]?.value === "(") {
+      throw unsupported(sql, "a window function in a live query is not maintainable");
+    }
+    if (AGGREGATE_FUNCTIONS.has(token.lower) && body[i + 1]?.value === "(") {
+      throw unsupported(sql, `the aggregate ${token.value} in a live query is not maintainable`);
+    }
+    const reason = UNSUPPORTED_WORDS.get(token.lower);
+    if (reason !== void 0 && token.depth === 0) {
+      throw unsupported(sql, `${reason} in a live query is not maintainable`);
+    }
+  }
+  if (body.some((token) => token.kind === "punct" && token.value === ";")) {
+    throw unsupported(sql, "a live query reads with one statement");
+  }
+}
+function assertDeterministic(sql, body) {
+  for (let i = 0; i < body.length; i++) {
+    const token = body[i];
+    if (token.kind !== "word" || token.quoted) continue;
+    if (CLOCK_KEYWORDS.has(token.lower)) {
+      throw volatileRead(sql, token.value);
+    }
+    const open = body[i + 1];
+    if (open === void 0 || open.kind !== "punct" || open.value !== "(") continue;
+    if (VOLATILE_FUNCTIONS.has(token.lower)) {
+      throw volatileRead(sql, `${token.value}()`);
+    }
+    if (CLOCK_FUNCTIONS.has(token.lower) && readsTheClock(token.lower, callArguments(body, i + 1))) {
+      throw volatileRead(sql, `${token.value}()`);
     }
   }
-};
+}
+function callArguments(body, openIndex) {
+  const outer = body[openIndex].depth;
+  const args = [];
+  let current = [];
+  for (let i = openIndex + 1; i < body.length; i++) {
+    const token = body[i];
+    if (token.kind === "punct" && token.value === ")" && token.depth === outer) break;
+    if (token.kind === "punct" && token.value === "," && token.depth === outer + 1) {
+      args.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) args.push(current);
+  return args;
+}
+function readsTheClock(name, args) {
+  if (args.length === 0) return true;
+  if (name === "strftime" && args.length === 1) return true;
+  return args.some((argument) => argument.some((token) => token.kind === "string" && CLOCK_MODIFIER.test(token.value)));
+}
+function volatileRead(sql, reference) {
+  return unsupported(
+    sql,
+    `${reference} returns a different value on each evaluation, and a live query only re-evaluates a row a change event touches, so its rows would go stale without any change to report`
+  );
+}
+function withoutTrailingSemicolon(tokens) {
+  const last = tokens[tokens.length - 1];
+  if (last !== void 0 && last.kind === "punct" && last.value === ";") return tokens.slice(0, -1);
+  return tokens;
+}
+
+// src/core/live/database-live.ts
+var DEFAULT_REREAD_JITTER_MS = 25;
+var DEFAULT_MAX_TRANSACTION_CHANGES = 1e4;
+var MAX_TRANSACTION_BYTES = 16 * 1048576;
+var nextProbeTable = 0;
+async function openLiveQuery(deps, sql, params, options) {
+  const shape = analyseStatement(sql);
+  await deps.watch(shape.table);
+  const { conn, run } = await deps.cdc.liveConnection();
+  const info = await run(() => tableInfoRows(conn, shape.table));
+  if (info.length === 0) {
+    throw new CDCError(`Cannot open a live query for '${sql}': table '${shape.table}' has no columns`);
+  }
+  const ddl = await run(() => selectTableSql(conn, shape.table));
+  const plan = buildLivePlan(
+    shape,
+    {
+      columns: info.map((column) => ({ name: column.name, type: column.type })),
+      collations: ddl === null ? /* @__PURE__ */ new Map() : parseColumnCollations(ddl),
+      pkColumns: info.filter((column) => column.pk > 0).sort((left, right) => left.pk - right.pk).map((column) => column.name)
+    },
+    params
+  );
+  const probeTable = `${LIVE_PROBE_TABLE_PREFIX}${nextProbeTable++}`;
+  const probe = await RowProbe.open(conn, probeTable, plan, params, run);
+  try {
+    return await MaintainedLiveQuery.open(buildSource(deps, conn, run, plan, probe, params, options));
+  } catch (err) {
+    await probe.close().catch(() => {
+    });
+    throw err;
+  }
+}
+function buildSource(deps, conn, run, plan, probe, params, options) {
+  const delivery = new PrimedLiveDelivery(deps.cdc, conn, run, plan.shape.table);
+  return {
+    plan,
+    probe,
+    rereadJitterMs: options?.rereadJitterMs ?? DEFAULT_REREAD_JITTER_MS,
+    maxTransactionChanges: options?.maxTransactionChanges ?? DEFAULT_MAX_TRANSACTION_CHANGES,
+    maxTransactionBytes: MAX_TRANSACTION_BYTES,
+    wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    read: () => readAtPosition2(deps.cdc, plan, params),
+    start: (handlers, sinceSeq) => delivery.start(handlers, sinceSeq),
+    release: () => probe.close()
+  };
+}
+async function readAtPosition2(cdc, plan, params) {
+  const captured = await cdc.readAtPositionWith(async (conn) => {
+    const stmt = await conn.prepare(plan.readSql);
+    return stmt.all(...bindRead(params));
+  });
+  return { rows: captured.value.map((row) => toHeldRow(plan, row)), seq: captured.seq };
+}
+function bindRead(params) {
+  if (params === void 0) return [];
+  return Array.isArray(params) ? params : [params];
+}
+function toHeldRow(plan, row) {
+  const key = plan.usesRowid ? rowidKey(row[plan.keyColumnAliases[0]]) : encodeRowKey(plan.keyColumnAliases.map((alias) => row[alias]));
+  const sort = plan.sortColumns.map((column, index) => toSortValue(row[column], plan.sortPlan.collations[index]));
+  for (const alias of plan.keyColumnAliases) delete row[alias];
+  for (const column of plan.sortColumns) delete row[column];
+  return { key, row, sort };
+}
+
+// src/core/migrations/concurrency.ts
+var BUSY_CODES = /* @__PURE__ */ new Set(["SQLITE_BUSY", "SQLITE_BUSY_SNAPSHOT", "SQLITE_BUSY_RECOVERY", "SQLITE_BUSY_TIMEOUT"]);
+function isConcurrentMigrationConflict(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (typeof code === "string" && BUSY_CODES.has(code)) return true;
+  const message = err.message;
+  if (/SQLITE_BUSY|database is locked/i.test(message)) return true;
+  return message.includes(`UNIQUE constraint failed: ${MIGRATIONS_TABLE}.version`);
+}
+
+// src/core/migrations/types.ts
+var MIGRATION_NAME_RE = /^\w+$/;
 
 // src/core/migrations/runner.ts
-var CREATE_TRACKING_TABLE = `
-  CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-    version INTEGER PRIMARY KEY,
-    name TEXT NOT NULL,
-    applied_at REAL NOT NULL DEFAULT (unixepoch('subsec'))
-  )
-`;
 var MigrationRunner = class _MigrationRunner {
   static async run(conn, migrations) {
-    await conn.exec(CREATE_TRACKING_TABLE);
     const validated = _MigrationRunner.validateMigrations(migrations);
-    const applied = await _MigrationRunner.getAppliedVersions(conn);
-    const pending = validated.filter((m) => !applied.has(m.version));
-    if (pending.length === 0) {
-      return { applied: [], skipped: validated.length };
-    }
-    const appliedEntries = [];
-    await conn.transaction(async (txConn) => {
-      const insertStmt = await txConn.prepare(`INSERT INTO ${MIGRATIONS_TABLE} (version, name) VALUES (?, ?)`);
+    const effectiveBaseline = resolveEffectiveBaseline(validated);
+    return _MigrationRunner.retryOnConcurrentConflict(
+      () => _MigrationRunner.applyPending(conn, validated, effectiveBaseline)
+    );
+  }
+  static async retryOnConcurrentConflict(operation) {
+    try {
+      return await operation();
+    } catch (err) {
+      if (!isConcurrentMigrationConflict(err)) throw err;
+    }
+    try {
+      return await operation();
+    } catch (err) {
+      if (!isConcurrentMigrationConflict(err)) throw err;
+      throw new MigrationError(
+        "Another process is writing to the migration history and the busy timeout elapsed; retry once it finishes",
+        0,
+        "MIGRATION_CONCURRENT"
+      );
+    }
+  }
+  static async applyPending(conn, validated, effectiveBaseline) {
+    return conn.transaction(async (txConn) => {
+      await ensureMigrationsTable(txConn);
+      const applied = await _MigrationRunner.getAppliedRows(txConn);
+      const backfills = reconcileMigrationChecksums(validated, applied);
+      if (backfills.length > 0) {
+        const updateStmt = await prepareUpdateMigrationChecksum(txConn);
+        for (const backfill of backfills) {
+          await updateStmt.run(backfill.checksum, backfill.version);
+        }
+      }
+      const pending = planPendingMigrations(validated, effectiveBaseline, new Set(applied.keys()));
+      if (pending.length === 0) {
+        await syncSchemaVersion(txConn, _MigrationRunner.highestVersion(applied.keys()));
+        return { applied: [], skipped: validated.length };
+      }
+      const appliedEntries = [];
+      const insertStmt = await prepareInsertMigration(txConn);
       for (const migration of pending) {
         try {
           if (typeof migration.up === "string") {
@@ -631,19 +2569,27 @@ var MigrationRunner = class _MigrationRunner {
           }
         } catch (err) {
           if (err instanceof MigrationError) throw err;
+          if (isConcurrentMigrationConflict(err)) throw err;
           throw new MigrationError(
             `Migration ${migration.version}_${migration.name} failed: ${err instanceof Error ? err.message : String(err)}`,
             migration.version
           );
         }
-        await insertStmt.run(migration.version, migration.name);
+        await insertStmt.run(migration.version, migration.name, migrationContentChecksum(migration));
         appliedEntries.push({ version: migration.version, name: migration.name });
       }
+      await mirrorSchemaVersion(
+        txConn,
+        Math.max(
+          _MigrationRunner.highestVersion(applied.keys()),
+          _MigrationRunner.highestVersion(appliedEntries.map((e) => e.version))
+        )
+      );
+      return {
+        applied: appliedEntries,
+        skipped: validated.length - pending.length
+      };
     });
-    return {
-      applied: appliedEntries,
-      skipped: validated.length - pending.length
-    };
   }
   static async rollback(conn, migrations, version) {
     if (version !== void 0 && (!Number.isSafeInteger(version) || version < 0)) {
@@ -653,76 +2599,92 @@ var MigrationRunner = class _MigrationRunner {
         "MIGRATION_VALIDATION_ERROR"
       );
     }
-    await conn.exec(CREATE_TRACKING_TABLE);
-    const selectStmt = await conn.prepare(`SELECT version, name FROM ${MIGRATIONS_TABLE} ORDER BY version DESC`);
-    const appliedRows = await selectStmt.all();
-    if (appliedRows.length === 0) {
-      return { rolledBack: [] };
-    }
-    let rollbackSet;
-    if (version === void 0) {
-      rollbackSet = [appliedRows[0]];
-    } else {
-      rollbackSet = appliedRows.filter((row) => row.version > version);
-    }
-    if (rollbackSet.length === 0) {
-      return { rolledBack: [] };
-    }
     _MigrationRunner.validateMigrations(migrations);
-    const rollbackVersions = rollbackSet.map((r) => r.version);
     const inputByVersion = new Map(migrations.map((m) => [m.version, m]));
-    const downByVersion = /* @__PURE__ */ new Map();
-    for (const v of rollbackVersions) {
-      const m = inputByVersion.get(v);
-      if (!m || m.down === void 0) {
-        throw new MigrationError(`Migration version ${v} has no down migration`, v, "MIGRATION_NO_DOWN");
-      }
-      downByVersion.set(v, m);
-    }
-    const rolledBackEntries = [];
-    await conn.transaction(async (txConn) => {
-      const deleteStmt = await txConn.prepare(`DELETE FROM ${MIGRATIONS_TABLE} WHERE version = ?`);
-      for (const entry of rollbackSet) {
-        const migration = downByVersion.get(entry.version);
-        if (!migration) {
-          throw new MigrationError(
-            `No down migration found for version ${entry.version}`,
+    return _MigrationRunner.retryOnConcurrentConflict(
+      () => conn.transaction(async (txConn) => {
+        await ensureMigrationsTable(txConn);
+        const appliedRows = await selectAppliedMigrationsNewestFirst(txConn);
+        if (appliedRows.length === 0) {
+          return { rolledBack: [] };
+        }
+        let rollbackSet;
+        if (version === void 0) {
+          rollbackSet = [appliedRows[0]];
+        } else {
+          rollbackSet = appliedRows.filter((row) => row.version > version);
+        }
+        if (rollbackSet.length === 0) {
+          return { rolledBack: [] };
+        }
+        const downByVersion = /* @__PURE__ */ new Map();
+        for (const entry of rollbackSet) {
+          downByVersion.set(
             entry.version,
-            "MIGRATION_ROLLBACK_ERROR"
+            _MigrationRunner.resolveDownMigration(inputByVersion.get(entry.version), entry.version)
           );
         }
-        try {
-          if (typeof migration.down === "string") {
-            await txConn.exec(migration.down);
-          } else {
-            const result = migration.down?.(new Transaction(txConn));
-            if (result instanceof Promise) await result;
+        const rolledBackEntries = [];
+        const deleteStmt = await prepareDeleteMigration(txConn);
+        for (const entry of rollbackSet) {
+          const migration = downByVersion.get(entry.version);
+          if (!migration) {
+            throw new MigrationError(
+              `No down migration found for version ${entry.version}`,
+              entry.version,
+              "MIGRATION_ROLLBACK_ERROR"
+            );
           }
-        } catch (err) {
-          if (err instanceof MigrationError) throw err;
-          throw new MigrationError(
-            `Rollback of migration ${entry.version}_${entry.name} failed: ${err instanceof Error ? err.message : String(err)}`,
-            entry.version,
-            "MIGRATION_ROLLBACK_ERROR"
-          );
+          try {
+            if (typeof migration.down === "string") {
+              await txConn.exec(migration.down);
+            } else {
+              const result = migration.down?.(new Transaction(txConn));
+              if (result instanceof Promise) await result;
+            }
+          } catch (err) {
+            if (err instanceof MigrationError) throw err;
+            if (isConcurrentMigrationConflict(err)) throw err;
+            throw new MigrationError(
+              `Rollback of migration ${entry.version}_${entry.name} failed: ${err instanceof Error ? err.message : String(err)}`,
+              entry.version,
+              "MIGRATION_ROLLBACK_ERROR"
+            );
+          }
+          await deleteStmt.run(entry.version);
+          rolledBackEntries.push({ version: entry.version, name: entry.name });
         }
-        await deleteStmt.run(entry.version);
-        rolledBackEntries.push({ version: entry.version, name: entry.name });
-      }
-    });
-    return { rolledBack: rolledBackEntries };
+        const rolledBackVersions = new Set(rollbackSet.map((r) => r.version));
+        const remaining = appliedRows.find((row) => !rolledBackVersions.has(row.version));
+        await mirrorSchemaVersion(txConn, remaining === void 0 ? 0 : remaining.version);
+        return { rolledBack: rolledBackEntries };
+      })
+    );
+  }
+  static resolveDownMigration(migration, version) {
+    if (!migration) {
+      throw new MigrationError(`Migration version ${version} has no down migration`, version, "MIGRATION_NO_DOWN");
+    }
+    if (migration.down !== void 0) {
+      return migration;
+    }
+    const readDown = migration[LAZY_DOWN_SQL];
+    if (readDown === void 0) {
+      throw new MigrationError(`Migration version ${version} has no down migration`, version, "MIGRATION_NO_DOWN");
+    }
+    return { version: migration.version, name: migration.name, up: migration.up, down: readDown() };
   }
   static validateMigrations(migrations) {
     const seenVersions = /* @__PURE__ */ new Map();
     for (const m of migrations) {
-      if (!Number.isSafeInteger(m.version) || m.version <= 0) {
+      if (!Number.isSafeInteger(m.version) || m.version <= 0 || m.version > SQLITE_USER_VERSION_MAX) {
         throw new MigrationError(
-          `Invalid migration version: ${m.version}`,
+          `Invalid migration version: ${m.version}. Versions must be integers from 1 to ${SQLITE_USER_VERSION_MAX} so they mirror to PRAGMA user_version`,
           typeof m.version === "number" && Number.isFinite(m.version) ? m.version : 0,
           "MIGRATION_VALIDATION_ERROR"
         );
       }
-      if (!/^\w+$/.test(m.name)) {
+      if (!MIGRATION_NAME_RE.test(m.name)) {
         throw new MigrationError(`Invalid migration name: '${m.name}'`, m.version, "MIGRATION_VALIDATION_ERROR");
       }
       const existing = seenVersions.get(m.version);
@@ -751,89 +2713,37 @@ var MigrationRunner = class _MigrationRunner {
     }
     return [...migrations].sort((a, b) => a.version - b.version);
   }
-  static async getAppliedVersions(conn) {
-    const stmt = await conn.prepare(`SELECT version FROM ${MIGRATIONS_TABLE} ORDER BY version`);
-    const rows = await stmt.all();
-    return new Set(rows.map((r) => r.version));
+  static highestVersion(versions) {
+    let highest = 0;
+    for (const version of versions) {
+      if (version > highest) highest = version;
+    }
+    return highest;
+  }
+  static async getAppliedRows(conn) {
+    const rows = await selectAppliedMigrations(conn);
+    return new Map(rows.map((r) => [r.version, { name: r.name, checksum: r.checksum }]));
   }
 };
 
-// src/core/worker/config.ts
-var DEFAULT_MAX_PENDING_WRITES = 1024;
-var DEFAULT_RETRY_AFTER_MS = 1e3;
-function requireCount(value, name, min) {
-  if (!Number.isInteger(value) || value < min) {
-    throw new SirannonError(`writerWorker.${name} must be an integer >= ${min}`, "INVALID_WRITER_WORKER");
-  }
-  return value;
+// src/core/database-migrations.ts
+async function refreshTriggersAfterSchemaChange(tracker, conn) {
+  if (!tracker || tracker.watchedTables.size === 0) return;
+  await tracker.refreshAllTriggersUsingConnection(conn);
 }
-function resolveWriterWorkerConfig(option) {
-  if (!option) {
-    return { enabled: false, maxPendingWrites: 0, retryAfterMs: DEFAULT_RETRY_AFTER_MS, host: {} };
-  }
-  const opts = option === true ? {} : option;
-  const host = {};
-  if (opts.writeTimeoutMs !== void 0) host.writeTimeoutMs = requireCount(opts.writeTimeoutMs, "writeTimeoutMs", 0);
-  if (opts.maxRestarts !== void 0) host.maxRestarts = requireCount(opts.maxRestarts, "maxRestarts", 0);
-  const maxPendingWrites = opts.maxPendingWrites === void 0 ? DEFAULT_MAX_PENDING_WRITES : requireCount(opts.maxPendingWrites, "maxPendingWrites", 1);
-  return { enabled: true, maxPendingWrites, retryAfterMs: DEFAULT_RETRY_AFTER_MS, host };
+async function migrateWithTriggerRefresh(conn, tracker, migrations) {
+  const result = await MigrationRunner.run(conn, migrations);
+  if (result.applied.length > 0) await refreshTriggersAfterSchemaChange(tracker, conn);
+  return result;
 }
-
-// src/core/worker/gate.ts
-var WriteGate = class {
-  constructor(limit, retryAfterMs) {
-    this.limit = limit;
-    this.retryAfterMs = retryAfterMs;
-  }
-  inFlight = 0;
-  run(op) {
-    if (this.limit > 0 && this.inFlight >= this.limit) {
-      return Promise.reject(new WriteOverloadError(this.limit, this.retryAfterMs));
-    }
-    this.inFlight++;
-    return op().finally(() => {
-      this.inFlight--;
-    });
-  }
-};
-
-// src/core/writer-lock.ts
-var UNTRACKED = {
-  run: (operation) => operation(),
-  isActive: () => false,
-  exit: (operation) => operation()
-};
-var WriterLock = class {
-  tail = Promise.resolve();
-  context;
-  constructor(context) {
-    this.context = context ?? UNTRACKED;
-  }
-  run(operation) {
-    if (this.context.isActive()) {
-      return operation();
-    }
-    const enter = () => this.context.run(operation);
-    const ticket = this.tail.then(enter, enter);
-    this.tail = ticket.then(swallow, swallow);
-    return ticket;
-  }
-  isHeld() {
-    return this.context.isActive();
-  }
-  async settle() {
-    await this.run(() => Promise.resolve());
-  }
-  /**
-   * Work scheduled from inside a held operation inherits it, so shared
-   * machinery must detach or it runs every caller's work inside one caller's
-   * transaction.
-   */
-  detached(operation) {
-    return this.context.exit(operation);
-  }
-};
-function swallow() {
+async function rollbackWithTriggerRefresh(conn, tracker, migrations, version) {
+  const result = await MigrationRunner.rollback(conn, migrations, version);
+  if (result.rolledBack.length > 0) await refreshTriggersAfterSchemaChange(tracker, conn);
+  return result;
+}
+async function readAppliedMigrations(conn) {
+  if (!await selectTableExists(conn, MIGRATIONS_TABLE)) return [];
+  return selectAppliedMigrations(conn);
 }
 
 // src/core/database.ts
@@ -851,105 +2761,53 @@ var Database = class _Database {
   closeListeners = [];
   _closed = false;
   cdc;
-  hookRegistry = new HookRegistry();
+  sync;
+  hookRegistry;
   observer;
   backups;
-  constructor(id, path, pool, driver, writeGate, options, internals) {
+  reads;
+  constructor(id, path, driver, runtime, options) {
     this.id = id;
     this.path = path;
-    this.pool = pool;
     this.driver = driver;
-    this.writeGate = writeGate;
-    this.writerLock = new WriterLock(driver.createWriterContext?.());
-    this.backups = new DatabaseBackupController(
-      (op) => this.writerLock.run(op),
-      () => this.pool.acquireWriter(),
-      driver.createBackupEngine?.()
-    );
+    this.pool = runtime.pool;
+    this.writeGate = runtime.writeGate;
+    this.writerLock = runtime.writerLock;
+    this.hookRegistry = runtime.hookRegistry;
+    this.observer = runtime.observer;
+    this.backups = runtime.backups;
+    this.cdc = runtime.cdc;
+    this.sync = runtime.sync;
+    this.groupCommitter = runtime.groupCommitter;
+    this.reads = { pool: runtime.pool, writerLock: runtime.writerLock, observer: runtime.observer };
     this.readOnly = options?.readOnly ?? false;
     this.synchronous = options?.synchronous ?? DEFAULT_SYNCHRONOUS;
     this.walMode = options?.walMode ?? true;
-    this.observer = new DatabaseObserver(
-      id,
-      this.hookRegistry,
-      internals?.parentHooks ?? null,
-      internals?.metrics ?? null
-    );
-    this.cdc = new DatabaseCdcController(
-      (op) => this.writerLock.run(op),
-      () => this.pool.acquireWriter(),
-      options?.cdcPollInterval ?? 50,
-      options?.cdcRetention ?? 36e5
-    );
-    this.groupCommitter = new GroupCommitter(this.writerLock, {
-      acquireWriter: () => this.pool.acquireWriter(),
-      afterCommit: (writer, sql) => applyDdlSideEffectsIfRelevant(this.cdc.changeTracker, writer, sql)
-    });
   }
   static async create(id, path, driver, options, internals) {
-    const writerWorker = resolveWriterWorkerConfig(options?.writerWorker);
-    const readOnly = options?.readOnly ?? false;
-    if (writerWorker.enabled && !readOnly && !driver.startWriterHost) {
-      throw new SirannonError(
-        `writerWorker is enabled for database '${id}' but the driver does not carry a worker entry; use a driver that supports worker offload or disable writerWorker`,
-        "WRITER_WORKER_UNSUPPORTED"
-      );
-    }
-    const pool = await ConnectionPool.create({
-      driver,
-      path,
-      readOnly: options?.readOnly,
-      readPoolSize: options?.readPoolSize ?? 4,
-      walMode: options?.walMode ?? true,
-      synchronous: options?.synchronous,
-      useWriterWorker: writerWorker.enabled && !readOnly,
-      workerHostOptions: writerWorker.host
-    });
-    const writeGate = new WriteGate(writerWorker.enabled ? writerWorker.maxPendingWrites : 0, writerWorker.retryAfterMs);
-    return new _Database(id, path, pool, driver, writeGate, options, internals);
+    const runtime = await createDatabaseRuntime(id, path, driver, options, internals);
+    return new _Database(id, path, driver, runtime, options);
+  }
+  async applyChanges(batch, resolver) {
+    this.ensureOpen();
+    if (this.readOnly) throw new ReadOnlyError(this.id);
+    return this.sync.applyChanges(batch, resolver);
+  }
+  deviceSync() {
+    this.ensureNotClosed();
+    return this.sync.devicePort();
   }
   async query(sql, params, options) {
     this.ensureOpen();
-    return this.observer.withQueryHooks(
-      sql,
-      params,
-      options,
-      () => this.runRead(sql, (conn) => query(conn, sql, params))
-    );
+    return readRows(this.reads, sql, params, options);
   }
-  /**
-   * Returns query rows already encoded for the wire (safe-range integers as
-   * plain numbers, larger integers and BLOBs as tagged envelopes) in a single
-   * pass. The server response path uses this so a read walks its values once
-   * rather than narrowing on the driver and re-scanning to tag.
-   */
   async queryForWire(sql, params, options) {
     this.ensureOpen();
-    return this.observer.withQueryHooks(
-      sql,
-      params,
-      options,
-      () => this.runRead(sql, (conn) => queryForWire(conn, sql, params))
-    );
+    return readWireRows(this.reads, sql, params, options);
   }
   async queryOne(sql, params, options) {
     this.ensureOpen();
-    return this.observer.withQueryHooks(
-      sql,
-      params,
-      options,
-      () => this.runRead(sql, (conn) => queryOne(conn, sql, params))
-    );
-  }
-  /**
-   * On a single-connection driver the reader is the writer, so serialise the
-   * read through the writer lock to avoid a bulk load's uncommitted rows.
-   */
-  runRead(sql, op) {
-    if (this.pool.readerCount === 0) {
-      return this.writerLock.run(() => this.observer.track(sql, () => op(this.pool.acquireWriter())));
-    }
-    return this.observer.track(sql, () => op(this.pool.acquireReader()));
+    return readOneRow(this.reads, sql, params, options);
   }
   async execute(sql, params, options) {
     this.ensureOpen();
@@ -981,7 +2839,14 @@ var Database = class _Database {
     );
   }
   async runInTransaction(writer, sql, run) {
-    const result = await this.observer.track(sql, () => writer.transaction(run));
+    const result = await this.observer.track(
+      sql,
+      () => writer.transaction(async (txConn) => {
+        const value = await run(txConn);
+        await this.cdc.applyStamps(txConn);
+        return value;
+      })
+    );
     await applyDdlSideEffectsIfRelevant(this.cdc.changeTracker, writer, sql);
     return result;
   }
@@ -1062,6 +2927,13 @@ var Database = class _Database {
     if (this._closed) return;
     await this.writerLock.run(() => op(this.pool.acquireWriter()));
   }
+  async ensureChangeStamping() {
+    this.ensureOpen();
+    if (this.readOnly) {
+      throw new ReadOnlyError(this.id);
+    }
+    await this.cdc.ensureStamping();
+  }
   async unwatch(table) {
     this.ensureOpen();
     await this.cdc.unwatch(table);
@@ -1070,13 +2942,26 @@ var Database = class _Database {
     this.ensureOpen();
     return this.cdc.on(table);
   }
+  async live(sql, params, options) {
+    this.ensureOpen();
+    if (this.readOnly) throw new ReadOnlyError(this.id);
+    return openLiveQuery({ cdc: this.cdc, watch: (table) => this.watch(table) }, sql, params, options);
+  }
   async migrate(migrations) {
     this.ensureOpen();
-    return this.writerLock.run(() => MigrationRunner.run(this.pool.acquireWriter(), migrations));
+    return this.writerLock.run(
+      () => migrateWithTriggerRefresh(this.pool.acquireWriter(), this.cdc.changeTracker, migrations)
+    );
+  }
+  async appliedMigrations() {
+    this.ensureNotClosed();
+    return this.writerLock.run(() => readAppliedMigrations(this.pool.acquireWriter()));
   }
   async rollback(migrations, version) {
     this.ensureOpen();
-    return this.writerLock.run(() => MigrationRunner.rollback(this.pool.acquireWriter(), migrations, version));
+    return this.writerLock.run(
+      () => rollbackWithTriggerRefresh(this.pool.acquireWriter(), this.cdc.changeTracker, migrations, version)
+    );
   }
   async backup(destPath) {
     this.ensureOpen();
@@ -1097,7 +2982,7 @@ var Database = class _Database {
     this.hookRegistry.register("afterQuery", hook);
   }
   addCloseListener(fn) {
-    this.ensureOpen();
+    this.ensureNotClosed();
     this.closeListeners.push(fn);
   }
   async close() {
@@ -1107,6 +2992,7 @@ var Database = class _Database {
     this.backups.cancelAll();
     let poolError;
     try {
+      await this.cdc.closeLiveConnection();
       await this.groupCommitter.drain();
       await this.writerLock.settle();
       await this.pool.close();
@@ -1130,6 +3016,15 @@ var Database = class _Database {
     return this.pool.readerCount;
   }
   ensureOpen() {
+    this.ensureNotClosed();
+    if (this.sync.snapshotLoadBlocked) {
+      throw new SirannonError(
+        `Database '${this.id}' is replacing its data from a sync snapshot; retry once the snapshot load completes`,
+        "SNAPSHOT_IN_PROGRESS"
+      );
+    }
+  }
+  ensureNotClosed() {
     if (this._closed) {
       throw new SirannonError(`Database '${this.id}' is closed`, "DATABASE_CLOSED");
     }
@@ -1353,6 +3248,71 @@ var MetricsCollector = class {
   }
 };
 
+// src/core/migrations/from-files.ts
+function basename(key) {
+  const separator = Math.max(key.lastIndexOf("/"), key.lastIndexOf("\\"));
+  return separator === -1 ? key : key.slice(separator + 1);
+}
+function migrationsFromFiles(files, options) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [key, contents] of Object.entries(files)) {
+    const parsed = parseMigrationFilename(basename(key));
+    if (!parsed) {
+      throw new MigrationError(
+        `Migration file '${key}' does not match the <version>_<name>.up.sql / <version>_<name>.down.sql convention`,
+        0,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    if (typeof contents !== "string") {
+      throw new MigrationError(
+        `Migration file '${key}' must map to its SQL text; received ${typeof contents}. When bundling with import.meta.glob, pass { query: '?raw', import: 'default', eager: true }`,
+        parsed.version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    const sql = contents.trim();
+    if (sql.length === 0) {
+      throw new MigrationError(`Migration file is empty: ${key}`, parsed.version, "MIGRATION_VALIDATION_ERROR");
+    }
+    const existing = grouped.get(parsed.version);
+    if (!existing) {
+      grouped.set(parsed.version, { name: parsed.name, [parsed.direction]: sql });
+      continue;
+    }
+    if (existing.name !== parsed.name) {
+      throw new MigrationError(
+        `Duplicate migration version ${parsed.version}: '${existing.name}' and '${parsed.name}'`,
+        parsed.version,
+        "MIGRATION_DUPLICATE_VERSION"
+      );
+    }
+    if (existing[parsed.direction] !== void 0) {
+      throw new MigrationError(
+        `Duplicate ${parsed.direction} migration for version ${parsed.version} ('${parsed.name}')`,
+        parsed.version,
+        "MIGRATION_DUPLICATE_VERSION"
+      );
+    }
+    existing[parsed.direction] = sql;
+  }
+  const migrations = [];
+  for (const [version, entry] of grouped) {
+    if (entry.up === void 0) {
+      throw new MigrationError(
+        `Migration version ${version} (${entry.name}) is missing an .up.sql file`,
+        version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    migrations.push(
+      entry.down === void 0 ? { version, name: entry.name, up: entry.up } : { version, name: entry.name, up: entry.up, down: entry.down }
+    );
+  }
+  migrations.sort((a, b) => a.version - b.version);
+  return applyBaselineOption(migrations, options?.baseline);
+}
+
 // src/core/sirannon.ts
 var Sirannon = class {
   constructor(options) {
@@ -1369,6 +3329,8 @@ var Sirannon = class {
   }
   dbs = /* @__PURE__ */ new Map();
   opening = /* @__PURE__ */ new Set();
+  resolving = /* @__PURE__ */ new Map();
+  migrationSet = null;
   _shutdown = false;
   _driver;
   hookRegistry;
@@ -1400,7 +3362,19 @@ var Sirannon = class {
         "DATABASE_OPEN_FAILED"
       );
     }
-    this.opening.delete(id);
+    try {
+      await this.applyRegistryMigrations(db);
+    } catch (err) {
+      await db.close().catch(() => {
+      });
+      if (err instanceof SirannonError) throw err;
+      throw new SirannonError(
+        `Failed to migrate database '${id}' at '${path}': ${err instanceof Error ? err.message : String(err)}`,
+        "DATABASE_OPEN_FAILED"
+      );
+    } finally {
+      this.opening.delete(id);
+    }
     if (this._shutdown) {
       await db.close().catch(() => {
       });
@@ -1464,7 +3438,49 @@ var Sirannon = class {
     const db = this.get(id);
     if (db) return db;
     if (this._shutdown) return void 0;
-    return this.lifecycleManager?.resolve(id);
+    const manager = this.lifecycleManager;
+    if (!manager) return void 0;
+    const pending = this.resolving.get(id);
+    if (pending) return pending;
+    const inFlight = manager.resolve(id).finally(() => {
+      this.resolving.delete(id);
+    });
+    this.resolving.set(id, inFlight);
+    return inFlight;
+  }
+  registryMigrations() {
+    return this.loadMigrationSet();
+  }
+  async applyRegistryMigrations(db) {
+    if (this.options.migrations === void 0 || db.readOnly) return;
+    const migrations = await this.loadMigrationSet();
+    if (migrations.length === 0) return;
+    await db.migrate(migrations);
+  }
+  loadMigrationSet() {
+    const source = this.options.migrations;
+    if (source === void 0 || Array.isArray(source)) {
+      return Promise.resolve(source ?? []);
+    }
+    if (this.migrationSet) return this.migrationSet;
+    const loading = (async () => {
+      const set = await source();
+      if (!Array.isArray(set)) {
+        throw new MigrationError(
+          "The migrations source must return an array of migrations",
+          0,
+          "MIGRATION_SOURCE_INVALID"
+        );
+      }
+      return set;
+    })();
+    loading.catch(() => {
+      if (this.migrationSet === loading) {
+        this.migrationSet = null;
+      }
+    });
+    this.migrationSet = loading;
+    return loading;
   }
   has(id) {
     return this.dbs.has(id);
@@ -1512,4 +3528,12 @@ var Sirannon = class {
   }
 };
 
-export { ConnectionPool, Database, HookRegistry, LifecycleManager, MetricsCollector, MigrationRunner, Sirannon, createTenantResolver, sanitizeTenantId, tenantPath };
+// src/core/operation-registry.ts
+function operationRef(name) {
+  return { name };
+}
+function operationName(operation) {
+  return typeof operation === "string" ? operation : operation.name;
+}
+
+export { ConnectionPool, Database, HookRegistry, LifecycleManager, MIGRATION_NAME_RE, MetricsCollector, MigrationRunner, Sirannon, createTenantResolver, migrationsFromFiles, operationName, operationRef, sanitizeTenantId, tenantPath };