@delali/sirannon-db 0.1.6 → 0.1.8

package/dist/driver/wa-sqlite.mjs

@@ -12,12 +12,40 @@ function defineDriver(config) {
   if (!config.capabilities || typeof config.open !== "function") {
     throw new SirannonError("Driver must define capabilities and open()", "INVALID_DRIVER");
   }
+  if (config.worker !== void 0 && typeof config.worker.specifier !== "string") {
+    throw new SirannonError("Driver worker entry must define a string specifier", "INVALID_DRIVER");
+  }
   return Object.freeze({
     capabilities: Object.freeze({ ...config.capabilities }),
-    open: config.open
+    open: config.open,
+    ...config.worker ? { worker: Object.freeze({ ...config.worker }) } : {},
+    ...config.startWriterHost ? { startWriterHost: config.startWriterHost } : {},
+    ...config.createWriterContext ? { createWriterContext: config.createWriterContext } : {},
+    ...config.createBackupEngine ? { createBackupEngine: config.createBackupEngine } : {},
+    ...config.resolveExtensionPath ? { resolveExtensionPath: config.resolveExtensionPath } : {}
   });
 }
 
+// src/core/driver/synchronous.ts
+var DEFAULT_SYNCHRONOUS = "normal";
+var SYNCHRONOUS_PRAGMA_VALUES = {
+  off: "OFF",
+  normal: "NORMAL",
+  full: "FULL",
+  extra: "EXTRA"
+};
+function synchronousPragmaValue(level) {
+  const resolved = level ?? DEFAULT_SYNCHRONOUS;
+  const value = SYNCHRONOUS_PRAGMA_VALUES[resolved];
+  if (value === void 0) {
+    throw new SirannonError(
+      `Invalid synchronous level '${String(resolved)}': expected 'off', 'normal', 'full', or 'extra'`,
+      "INVALID_SYNCHRONOUS"
+    );
+  }
+  return value;
+}
+
 // src/drivers/wa-sqlite/index.ts
 function waSqlite(driverOptions) {
   return defineDriver({
@@ -46,7 +74,7 @@ function waSqlite(driverOptions) {
         } catch {
         }
       }
-      await sqlite3.exec(db, "PRAGMA synchronous = NORMAL");
+      await sqlite3.exec(db, `PRAGMA synchronous = ${synchronousPragmaValue(options?.synchronous)}`);
       await sqlite3.exec(db, "PRAGMA foreign_keys = ON");
       async function execStatements(sql, params) {
         const columns = [];

package/dist/{errors-C00ed08Q.d.ts → errors-5Nf5ZAEC.d.ts}

@@ -67,6 +67,15 @@ declare class HookDeniedError extends SirannonError {
 declare class CDCError extends SirannonError {
     constructor(message: string);
 }
+/**
+ * Thrown when a caller reaches for a table Sirannon reserves for itself. The
+ * internal bookkeeping tables and SQLite's own catalogue are off limits to the
+ * query API so a caller cannot read or corrupt the change log, replication
+ * ledger, or schema catalogue.
+ */
+declare class ForbiddenSqlError extends SirannonError {
+    constructor(message: string);
+}
 /**
  * Thrown when a backup operation fails, whether that is an online backup via
  * the SQLite backup API or a file-level copy.
@@ -89,6 +98,15 @@ declare class ConnectionPoolError extends SirannonError {
 declare class MaxDatabasesError extends SirannonError {
     constructor(max: number);
 }
+/**
+ * Thrown when more writes are pending than the writer-worker limit allows. It
+ * signals load shedding, so the server maps it to a 503 with a Retry-After hint.
+ */
+declare class WriteOverloadError extends SirannonError {
+    readonly limit: number;
+    readonly retryAfterMs: number;
+    constructor(limit: number, retryAfterMs: number);
+}
 /**
  * Thrown when a native SQLite extension cannot be loaded. The `path` argument
  * is the filesystem path passed to `load_extension`, and the optional `cause`
@@ -98,4 +116,4 @@ declare class ExtensionError extends SirannonError {
     constructor(path: string, cause?: string);
 }
 
-export { BackupError as B, CDCError as C, DatabaseAlreadyExistsError as D, ExtensionError as E, HookDeniedError as H, MaxDatabasesError as M, QueryError as Q, ReadOnlyError as R, SirannonError as S, TransactionError as T, ConnectionPoolError as a, DatabaseNotFoundError as b, MigrationError as c };
+export { BackupError as B, CDCError as C, DatabaseAlreadyExistsError as D, ExtensionError as E, ForbiddenSqlError as F, HookDeniedError as H, MaxDatabasesError as M, QueryError as Q, ReadOnlyError as R, SirannonError as S, TransactionError as T, WriteOverloadError as W, ConnectionPoolError as a, DatabaseNotFoundError as b, MigrationError as c };

package/dist/file-migrations/index.d.ts

@@ -1,6 +1,5 @@
-import { M as Migration } from '../types-BeozgNPr.js';
-import '../types-D-74JiXb.js';
-import '../types-BFSsG77t.js';
+import { M as Migration } from '../types-D4p4UyDK.js';
+import '../types-D_hQW1hr.js';
 
 interface ScannedMigration {
     version: number;

package/dist/file-migrations/index.mjs

@@ -1,4 +1,4 @@
-import { MigrationError } from '../chunk-O7BHI3CF.mjs';
+import { MigrationError } from '../chunk-YPYVQJ4C.mjs';
 import { statSync, readdirSync, readFileSync } from 'fs';
 import { resolve, join } from 'path';
 

package/dist/replication/coordinator/etcd.mjs

@@ -1,6 +1,6 @@
 import { compatibilityAllowsPromotion } from '../../chunk-ER7ODTDA.mjs';
-import { CoordinatorError, NoSafePrimaryError } from '../../chunk-UVMVN3OT.mjs';
-import '../../chunk-O7BHI3CF.mjs';
+import { CoordinatorError, NoSafePrimaryError } from '../../chunk-H5AB6NIR.mjs';
+import '../../chunk-YPYVQJ4C.mjs';
 import { Etcd3 } from 'etcd3';
 
 var MIN_AUTOMATIC_FAILOVER_VOTERS = 3;

package/dist/replication/index.d.ts

@@ -1,14 +1,13 @@
-import { C as ConflictResolver, h as ConflictContext, i as ConflictResolution, H as HLCTimestamp, R as ReplicationBatch, A as ApplyResult, j as SyncPhase, k as SyncTableManifest, I as InFlightBatch, P as PeerState, b as ForwardedTransactionResult, c as SyncBatch, d as SyncComplete, e as SyncAck, S as SyncRequest, l as ReplicationConfig, m as SyncState, n as ReplicationStatus, o as ReplicationErrorEvent, a as ReplicationAck, p as Topology, T as TopologyRole } from '../types-Lc7ywFx7.js';
-export { F as ForwardedTransaction, N as NodeInfo, q as ReplicationChange, f as ReplicationTransport, g as TransportConfig } from '../types-Lc7ywFx7.js';
+import { C as ConflictResolver, h as ConflictContext, i as ConflictResolution, H as HLCTimestamp, R as ReplicationBatch, A as ApplyResult, j as SyncPhase, k as SyncTableManifest, I as InFlightBatch, P as PeerState, b as ForwardedTransactionResult, c as SyncBatch, d as SyncComplete, e as SyncAck, S as SyncRequest, l as ReplicationConfig, m as SyncState, n as ReplicationStatus, o as ReplicationErrorEvent, a as ReplicationAck, p as Topology, T as TopologyRole } from '../types-BsjobKbl.js';
+export { F as ForwardedTransaction, N as NodeInfo, q as ReplicationChange, f as ReplicationTransport, g as TransportConfig } from '../types-BsjobKbl.js';
 import { c as ReplicationGroupState } from '../types-BEu1I_9_.js';
 export { A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, h as AdmitNodeToInSyncSetInput, C as ClusterCoordinator, f as CompareAndAdvancePrimaryTermInput, g as CompareAndAdvancePrimaryTermResult, j as CoordinatorCompatibilityMetadata, k as CoordinatorLease, b as CoordinatorNodeSession, l as CoordinatorPrimary, e as CoordinatorWatchDisposer, P as PromoteEligibleReplicaInput, R as RegisterNodeSessionInput, d as ReplicationGroupWatcher, S as SetReplicationGroupStateInput, U as UpdateInSyncSetInput, i as UpdateNodeMaintenanceInput } from '../types-BEu1I_9_.js';
 import { EventEmitter } from 'node:events';
-import { C as ChangeTracker } from '../change-tracker-CFTQ9TSn.js';
-import { D as Database } from '../database-BVY1GqE7.js';
-import { a as SQLiteConnection } from '../types-BFSsG77t.js';
-import { P as Params, k as QueryOptions, T as Transaction, E as ExecuteResult } from '../types-D-74JiXb.js';
-import { S as SirannonError } from '../errors-C00ed08Q.js';
-import '../types-BeozgNPr.js';
+import { C as ChangeTracker } from '../change-tracker-CbmaMO-N.js';
+import { D as Database } from '../database-DuGp0Rtr.js';
+import { e as SQLiteConnection, P as Params, p as QueryOptions, T as Transaction, E as ExecuteResult } from '../types-D_hQW1hr.js';
+import { S as SirannonError } from '../errors-5Nf5ZAEC.js';
+import '../types-D4p4UyDK.js';
 
 type ColumnVersionGetter = (table: string, rowId: string) => Promise<Map<string, {
     hlc: string;

package/dist/replication/index.mjs

@@ -1,9 +1,10 @@
-import { Transaction } from '../chunk-3MCMONVP.mjs';
-import { decodeTaggedValues } from '../chunk-GS7T5YMI.mjs';
 import { compatibilityAllowsPromotion } from '../chunk-ER7ODTDA.mjs';
-import { ReplicationError, WriteConcernError, AuthorityError, SyncError, TopologyError, CoordinatorError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError, BatchValidationError } from '../chunk-UVMVN3OT.mjs';
-export { AuthorityError, BatchValidationError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, ReplicationError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-UVMVN3OT.mjs';
-import '../chunk-O7BHI3CF.mjs';
+import { ReplicationError, WriteConcernError, AuthorityError, SyncError, TopologyError, CoordinatorError, StalePrimaryError, NodeDrainingError, NodeNotInSyncError, ReadConcernError, ProtocolVersionMismatchError, BatchValidationError } from '../chunk-H5AB6NIR.mjs';
+export { AuthorityError, BatchValidationError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, ReplicationError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError } from '../chunk-H5AB6NIR.mjs';
+import { Transaction } from '../chunk-TKGHYWQ6.mjs';
+import '../chunk-CW6S3WL5.mjs';
+import { CHANGES_TABLE, APPLIED_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, INTERNAL_TABLE_PREFIX, decodeTaggedValues } from '../chunk-GEZUUIKV.mjs';
+import '../chunk-YPYVQJ4C.mjs';
 import { randomBytes, randomUUID, createHash } from 'crypto';
 import { EventEmitter } from 'events';
 
@@ -77,6 +78,43 @@ var HLC = class _HLC {
   }
 };
 
+// src/replication/log/canonicalise.ts
+function canonicaliseForChecksum(value) {
+  return canonicaliseValue(value);
+}
+function canonicaliseValue(v) {
+  if (v === null || v === void 0) return "null";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "string") return JSON.stringify(v);
+  if (typeof v === "bigint") return `{"__sint":"${v.toString()}"}`;
+  if (typeof v === "number") {
+    if (Number.isInteger(v)) return `{"__sint":"${v.toString()}"}`;
+    if (Number.isFinite(v)) return JSON.stringify(v);
+    return "null";
+  }
+  if (typeof v === "object") {
+    if (v instanceof Uint8Array) {
+      const buf = Buffer.isBuffer(v) ? v : Buffer.from(v);
+      return `{"__blob":"${buf.toString("base64")}"}`;
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(v)) {
+      return `{"__blob":"${v.toString("base64")}"}`;
+    }
+    if (Array.isArray(v)) {
+      return `[${v.map(canonicaliseValue).join(",")}]`;
+    }
+    const obj = v;
+    const parts = [];
+    for (const key of Object.keys(obj).sort()) {
+      const val = obj[key];
+      if (val === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicaliseValue(val)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  return "null";
+}
+
 // src/replication/conflict/lww.ts
 var LWWResolver = class {
   resolve(ctx) {
@@ -115,12 +153,12 @@ var FieldMergeResolver = class {
     const localChanged = /* @__PURE__ */ new Set();
     const remoteChanged = /* @__PURE__ */ new Set();
     for (const key of Object.keys(localData)) {
-      if (JSON.stringify(localData[key]) !== JSON.stringify(oldData[key])) {
+      if (canonicaliseForChecksum(localData[key]) !== canonicaliseForChecksum(oldData[key])) {
         localChanged.add(key);
       }
     }
     for (const key of Object.keys(remoteData)) {
-      if (JSON.stringify(remoteData[key]) !== JSON.stringify(oldData[key])) {
+      if (canonicaliseForChecksum(remoteData[key]) !== canonicaliseForChecksum(oldData[key])) {
         remoteChanged.add(key);
       }
     }
@@ -189,43 +227,6 @@ var PrimaryWinsResolver = class {
   }
 };
 
-// src/replication/log/canonicalise.ts
-function canonicaliseForChecksum(value) {
-  return canonicaliseValue(value);
-}
-function canonicaliseValue(v) {
-  if (v === null || v === void 0) return "null";
-  if (typeof v === "boolean") return v ? "true" : "false";
-  if (typeof v === "string") return JSON.stringify(v);
-  if (typeof v === "bigint") return `{"__sint":"${v.toString()}"}`;
-  if (typeof v === "number") {
-    if (Number.isInteger(v)) return `{"__sint":"${v.toString()}"}`;
-    if (Number.isFinite(v)) return JSON.stringify(v);
-    return "null";
-  }
-  if (typeof v === "object") {
-    if (v instanceof Uint8Array) {
-      const buf = Buffer.isBuffer(v) ? v : Buffer.from(v);
-      return `{"__blob":"${buf.toString("base64")}"}`;
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(v)) {
-      return `{"__blob":"${v.toString("base64")}"}`;
-    }
-    if (Array.isArray(v)) {
-      return `[${v.map(canonicaliseValue).join(",")}]`;
-    }
-    const obj = v;
-    const parts = [];
-    for (const key of Object.keys(obj).sort()) {
-      const val = obj[key];
-      if (val === void 0) continue;
-      parts.push(`${JSON.stringify(key)}:${canonicaliseValue(val)}`);
-    }
-    return `{${parts.join(",")}}`;
-  }
-  return "null";
-}
-
 // src/replication/engine/constants.ts
 var DEFAULT_BATCH_SIZE = 100;
 var DEFAULT_BATCH_INTERVAL_MS = 100;
@@ -359,7 +360,7 @@ var BatchReader = class {
     const rows = await selectStmt.all(afterSeq.toString(), this.localNodeId);
     for (const row of rows) {
       if (row.operation === "DELETE") {
-        const delStmt = await tx.prepare("DELETE FROM _sirannon_column_versions WHERE table_name = ? AND row_id = ?");
+        const delStmt = await tx.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`);
         await delStmt.run(row.table_name, String(row.row_id));
         continue;
       }
@@ -378,7 +379,7 @@ var BatchReader = class {
         }
       }
       const upsertStmt = await tx.prepare(
-        `INSERT INTO _sirannon_column_versions (table_name, row_id, column_name, hlc, node_id)
+        `INSERT INTO ${COLUMN_VERSIONS_TABLE} (table_name, row_id, column_name, hlc, node_id)
          VALUES (?, ?, ?, ?, ?)
          ON CONFLICT(table_name, row_id, column_name)
          DO UPDATE SET hlc = excluded.hlc, node_id = excluded.node_id`
@@ -443,7 +444,7 @@ var BatchApplier = class {
     if (needsPartialDedup) {
       appliedSeqSet = /* @__PURE__ */ new Set();
       const checkStmt = await this.conn.prepare(
-        "SELECT source_seq FROM _sirannon_applied_changes WHERE source_node_id = ? AND source_seq >= ? AND source_seq <= ?"
+        `SELECT source_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ? AND source_seq >= ? AND source_seq <= ?`
       );
       const applied2 = await checkStmt.all(
         batch.sourceNodeId,
@@ -548,7 +549,7 @@ var BatchApplier = class {
       }
     }
     const recordStmt = await this.conn.prepare(
-      "INSERT OR IGNORE INTO _sirannon_applied_changes (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)"
+      `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
     );
     const nowSec = Date.now() / 1e3;
     for (let seq = batch.fromSeq; seq <= batch.toSeq; seq += 1n) {
@@ -573,7 +574,7 @@ var BatchApplier = class {
   }
   async getLocalHlcForRow(tx, table, rowId) {
     const stmt = await tx.prepare(
-      "SELECT MAX(hlc) as max_hlc FROM _sirannon_column_versions WHERE table_name = ? AND row_id = ?"
+      `SELECT MAX(hlc) as max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`
     );
     const row = await stmt.get(table, rowId);
     return row?.max_hlc ?? null;
@@ -660,13 +661,13 @@ var BatchApplier = class {
   }
   async recordColumnVersions(tx, change, data) {
     if (change.operation === "delete") {
-      const delStmt = await tx.prepare("DELETE FROM _sirannon_column_versions WHERE table_name = ? AND row_id = ?");
+      const delStmt = await tx.prepare(`DELETE FROM ${COLUMN_VERSIONS_TABLE} WHERE table_name = ? AND row_id = ?`);
       await delStmt.run(change.table, change.rowId);
       return;
     }
     if (!data) return;
     const upsertStmt = await tx.prepare(
-      `INSERT INTO _sirannon_column_versions (table_name, row_id, column_name, hlc, node_id)
+      `INSERT INTO ${COLUMN_VERSIONS_TABLE} (table_name, row_id, column_name, hlc, node_id)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(table_name, row_id, column_name)
        DO UPDATE SET hlc = excluded.hlc, node_id = excluded.node_id`
@@ -931,21 +932,21 @@ CREATE TABLE IF NOT EXISTS "${this.changesTable}" (
 	hlc TEXT NOT NULL DEFAULT ''
 )`);
     await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS _sirannon_peer_state (
+CREATE TABLE IF NOT EXISTS ${PEER_STATE_TABLE} (
 	peer_node_id TEXT PRIMARY KEY,
 	last_acked_seq INTEGER NOT NULL DEFAULT 0,
 	last_received_hlc TEXT NOT NULL DEFAULT '',
 	updated_at REAL NOT NULL
 )`);
     await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS _sirannon_applied_changes (
+CREATE TABLE IF NOT EXISTS ${APPLIED_CHANGES_TABLE} (
 	source_node_id TEXT NOT NULL,
 	source_seq INTEGER NOT NULL,
 	applied_at REAL NOT NULL,
 	PRIMARY KEY (source_node_id, source_seq)
 )`);
     await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS _sirannon_column_versions (
+CREATE TABLE IF NOT EXISTS ${COLUMN_VERSIONS_TABLE} (
 	table_name TEXT NOT NULL,
 	row_id TEXT NOT NULL,
 	column_name TEXT NOT NULL,
@@ -954,7 +955,7 @@ CREATE TABLE IF NOT EXISTS _sirannon_column_versions (
 	PRIMARY KEY (table_name, row_id, column_name)
 )`);
     await this.conn.exec(`
-CREATE TABLE IF NOT EXISTS _sirannon_sync_state (
+CREATE TABLE IF NOT EXISTS ${SYNC_STATE_TABLE} (
 	table_name TEXT PRIMARY KEY,
 	status TEXT NOT NULL DEFAULT 'pending',
 	row_count INTEGER NOT NULL DEFAULT 0,
@@ -966,7 +967,7 @@ CREATE TABLE IF NOT EXISTS _sirannon_sync_state (
 	request_id TEXT
 )`);
   }
-  async dumpSchema(conn, excludePrefix = "_sirannon_") {
+  async dumpSchema(conn, excludePrefix = INTERNAL_TABLE_PREFIX) {
     const stmt = await conn.prepare(
       `SELECT type, name, sql FROM sqlite_master
        WHERE type IN ('table', 'index') AND name NOT LIKE ? AND name NOT LIKE 'sqlite_%' AND sql IS NOT NULL`
@@ -1003,7 +1004,7 @@ CREATE TABLE IF NOT EXISTS _sirannon_sync_state (
   }
   async getTablesInFkOrder(conn) {
     const stmt = await conn.prepare(
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE '_sirannon_%' AND name NOT LIKE 'sqlite_%'`
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE '${INTERNAL_TABLE_PREFIX}%' AND name NOT LIKE 'sqlite_%'`
     );
     const tableRows = await stmt.all();
     const tableNames = tableRows.map((r) => r.name);
@@ -1070,7 +1071,7 @@ CREATE TABLE IF NOT EXISTS _sirannon_sync_state (
         for (const table of reversed) {
           await tx.exec(`DELETE FROM "${table}"`);
         }
-        await tx.exec(`DELETE FROM _sirannon_sync_state WHERE table_name != '__sync_meta__'`);
+        await tx.exec(`DELETE FROM ${SYNC_STATE_TABLE} WHERE table_name != '__sync_meta__'`);
       });
     } finally {
       await conn.exec("PRAGMA foreign_keys = ON");
@@ -1118,7 +1119,7 @@ var StateOps = class {
     const changesRow = await changesStmt.get();
     best = mergeCandidate(best, changesRow?.max_hlc ?? null);
     const versionsStmt = await this.conn.prepare(
-      `SELECT MAX(hlc) AS max_hlc FROM _sirannon_column_versions WHERE hlc != ''`
+      `SELECT MAX(hlc) AS max_hlc FROM ${COLUMN_VERSIONS_TABLE} WHERE hlc != ''`
     );
     const versionsRow = await versionsStmt.get();
     best = mergeCandidate(best, versionsRow?.max_hlc ?? null);
@@ -1126,7 +1127,7 @@ var StateOps = class {
   }
   async getLastAppliedSeq(fromNodeId) {
     const stmt = await this.conn.prepare(
-      "SELECT MAX(source_seq) as max_seq FROM _sirannon_applied_changes WHERE source_node_id = ?"
+      `SELECT MAX(source_seq) as max_seq FROM ${APPLIED_CHANGES_TABLE} WHERE source_node_id = ?`
     );
     const row = await stmt.get(fromNodeId);
     if (!row || row.max_seq === null) {
@@ -1136,20 +1137,20 @@ var StateOps = class {
   }
   async setLastAppliedSeq(fromNodeId, seq) {
     const stmt = await this.conn.prepare(
-      `INSERT INTO _sirannon_peer_state (peer_node_id, last_acked_seq, updated_at)
+      `INSERT INTO ${PEER_STATE_TABLE} (peer_node_id, last_acked_seq, updated_at)
        VALUES (?, ?, ?)
        ON CONFLICT(peer_node_id)
        DO UPDATE SET
-         last_acked_seq = max(_sirannon_peer_state.last_acked_seq, excluded.last_acked_seq),
+         last_acked_seq = max(${PEER_STATE_TABLE}.last_acked_seq, excluded.last_acked_seq),
          updated_at = CASE
-           WHEN excluded.last_acked_seq >= _sirannon_peer_state.last_acked_seq THEN excluded.updated_at
-           ELSE _sirannon_peer_state.updated_at
+           WHEN excluded.last_acked_seq >= ${PEER_STATE_TABLE}.last_acked_seq THEN excluded.updated_at
+           ELSE ${PEER_STATE_TABLE}.updated_at
          END`
     );
     await stmt.run(fromNodeId, seq.toString(), Date.now() / 1e3);
   }
   async getPeerAckedSeq(peerNodeId) {
-    const stmt = await this.conn.prepare("SELECT last_acked_seq FROM _sirannon_peer_state WHERE peer_node_id = ?");
+    const stmt = await this.conn.prepare(`SELECT last_acked_seq FROM ${PEER_STATE_TABLE} WHERE peer_node_id = ?`);
     const row = await stmt.get(peerNodeId);
     if (!row || row.last_acked_seq === null) {
       return 0n;
@@ -1166,7 +1167,7 @@ var StateOps = class {
   }
   async getMinAckedSeq() {
     const stmt = await this.conn.prepare(
-      "SELECT MIN(last_acked_seq) as min_seq, COUNT(*) as cnt FROM _sirannon_peer_state"
+      `SELECT MIN(last_acked_seq) as min_seq, COUNT(*) as cnt FROM ${PEER_STATE_TABLE}`
     );
     const row = await stmt.get();
     const hasPeers = row !== void 0 && row.cnt > 0;
@@ -1191,7 +1192,7 @@ var StateOps = class {
   }
   async setSyncTableStatus(table, status, rowCount, pkHash) {
     const stmt = await this.conn.prepare(
-      `INSERT INTO _sirannon_sync_state (table_name, status, row_count, pk_hash, completed_at)
+      `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, row_count, pk_hash, completed_at)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(table_name) DO UPDATE SET
          status = excluded.status,
@@ -1203,7 +1204,7 @@ var StateOps = class {
   }
   async setSyncMeta(phase, snapshotSeq, sourcePeerId, requestId) {
     const stmt = await this.conn.prepare(
-      `INSERT INTO _sirannon_sync_state (table_name, status, snapshot_seq, source_peer_id, started_at, request_id)
+      `INSERT INTO ${SYNC_STATE_TABLE} (table_name, status, snapshot_seq, source_peer_id, started_at, request_id)
        VALUES ('__sync_meta__', ?, ?, ?, ?, ?)
        ON CONFLICT(table_name) DO UPDATE SET
          status = excluded.status,
@@ -1222,14 +1223,14 @@ var StateOps = class {
   }
   async getSyncState() {
     const metaStmt = await this.conn.prepare(
-      `SELECT status, snapshot_seq, source_peer_id FROM _sirannon_sync_state WHERE table_name = '__sync_meta__'`
+      `SELECT status, snapshot_seq, source_peer_id FROM ${SYNC_STATE_TABLE} WHERE table_name = '__sync_meta__'`
     );
     const meta = await metaStmt.get();
     if (!meta) {
       return { phase: "ready", completedTables: [], snapshotSeq: null, sourcePeerId: null };
     }
     const completedStmt = await this.conn.prepare(
-      `SELECT table_name FROM _sirannon_sync_state WHERE table_name != '__sync_meta__' AND status = 'completed'`
+      `SELECT table_name FROM ${SYNC_STATE_TABLE} WHERE table_name != '__sync_meta__' AND status = 'completed'`
     );
     const completedRows = await completedStmt.all();
     return {
@@ -1240,7 +1241,7 @@ var StateOps = class {
     };
   }
   async isSyncCompleted() {
-    const stmt = await this.conn.prepare(`SELECT status FROM _sirannon_sync_state WHERE table_name = '__sync_meta__'`);
+    const stmt = await this.conn.prepare(`SELECT status FROM ${SYNC_STATE_TABLE} WHERE table_name = '__sync_meta__'`);
     const row = await stmt.get();
     return row?.status === "ready";
   }
@@ -1267,7 +1268,7 @@ function mergeCandidate(current, candidate) {
 
 // src/replication/log/log.ts
 var ReplicationLog = class {
-  constructor(conn, localNodeId, hlc, changesTable = "_sirannon_changes", tracker) {
+  constructor(conn, localNodeId, hlc, changesTable = CHANGES_TABLE, tracker) {
     this.changesTable = changesTable;
     this.pkResolver = new PkResolver(conn);
     this.state = new StateOps(conn);
@@ -1672,7 +1673,7 @@ var LocalExecutor = class {
       const r = await stmt.run(...bindValues);
       if (isDdl) {
         const ddlStmt = await tx.prepare(
-          `INSERT INTO "_sirannon_changes" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
+          `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
            VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
         );
         const hlcVal = engine.hlc.now();
@@ -1738,7 +1739,7 @@ var LocalExecutor = class {
             droppedTables.push(droppedTable);
           }
           const ddlStmt = await tx.prepare(
-            `INSERT INTO "_sirannon_changes" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
+            `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
              VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
           );
           const hlcVal = engine.hlc.now();
@@ -1789,7 +1790,7 @@ var LocalExecutor = class {
           hooks.droppedTables.push(droppedTable);
         }
         const ddlStmt = await tx.prepare(
-          `INSERT INTO "_sirannon_changes" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
+          `INSERT INTO "${CHANGES_TABLE}" (table_name, operation, row_id, new_data, node_id, tx_id, hlc)
            VALUES ('__ddl__', 'DDL', '', ?, ?, ?, ?)`
         );
         const hlcVal = engine.hlc.now();
@@ -2433,7 +2434,7 @@ var SyncJoiner = class {
       }
       await engine.log.setLastAppliedSeq(fromPeerId, complete.snapshotSeq);
       const recordStmt = await engine.writerConn.prepare(
-        "INSERT OR IGNORE INTO _sirannon_applied_changes (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)"
+        `INSERT OR IGNORE INTO ${APPLIED_CHANGES_TABLE} (source_node_id, source_seq, applied_at) VALUES (?, ?, ?)`
       );
       await recordStmt.run(fromPeerId, complete.snapshotSeq.toString(), Date.now() / 1e3);
       const previousApplied = engine.appliedSeqByPeer.get(fromPeerId) ?? 0n;
@@ -2929,7 +2930,7 @@ var ReplicationEngine = class extends EventEmitter {
     this.nodeId = config.nodeId ?? generateNodeId();
     this.hlc = new HLC(this.nodeId);
     this.tracker = config.changeTracker;
-    this.log = new ReplicationLog(writerConn, this.nodeId, this.hlc, "_sirannon_changes", this.tracker);
+    this.log = new ReplicationLog(writerConn, this.nodeId, this.hlc, CHANGES_TABLE, this.tracker);
     this.defaultResolver = config.defaultConflictResolver ?? new LWWResolver();
     this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
     this.batchIntervalMs = config.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
@@ -3122,7 +3123,7 @@ var ReplicationEngine = class extends EventEmitter {
   }
   async loadAppliedSeqs() {
     const stmt = await this.writerConn.prepare(
-      "SELECT source_node_id, MAX(source_seq) AS max_seq FROM _sirannon_applied_changes GROUP BY source_node_id"
+      `SELECT source_node_id, MAX(source_seq) AS max_seq FROM ${APPLIED_CHANGES_TABLE} GROUP BY source_node_id`
     );
     const rows = await stmt.all();
     for (const row of rows) {