reflectdb 0.1.0 → 0.1.2

package/dist/cjs/server/index.cjs

@@ -41,16 +41,16 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core/types.ts
 var exports_types = {};
 __export(exports_types, {
-  reasonFromError: () => reasonFromError,
-  isErrorReason: () => isErrorReason,
-  TransportSendError: () => TransportSendError,
-  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  MutationError: () => MutationError,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+  MutationError: () => MutationError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  TransportSendError: () => TransportSendError,
+  isErrorReason: () => isErrorReason,
+  reasonFromError: () => reasonFromError
 });
 function isErrorReason(value) {
   return typeof value === "string" && VALID_ERROR_REASONS.has(value);
@@ -107,8 +107,8 @@ var init_types = __esm(() => {
 // src/server/drizzle.ts
 var exports_drizzle = {};
 __export(exports_drizzle, {
-  drizzleTxAtomic: () => drizzleTxAtomic,
-  drizzleTable: () => drizzleTable
+  drizzleTable: () => drizzleTable,
+  drizzleTxAtomic: () => drizzleTxAtomic
 });
 module.exports = __toCommonJS(exports_drizzle);
 var import_node_module2 = require("node:module");
@@ -481,30 +481,30 @@ var drizzleTxAtomic = {
 // src/server/index.ts
 var exports_server = {};
 __export(exports_server, {
-  stableStringify: () => stableStringify,
-  resolveRoomKey: () => resolveRoomKey,
-  resolveConflict: () => resolveConflict,
-  processOp: () => processOp,
-  enforceServerSet: () => enforceServerSet,
-  enforceReadonly: () => enforceReadonly,
-  enforceClockDrift: () => enforceClockDrift,
-  enforceBatchSize: () => enforceBatchSize,
-  drizzleTxAtomic: () => drizzleTxAtomic,
-  drizzleTable: () => drizzleTable,
-  defineTable: () => defineTable,
-  createSyncServer: () => createSyncServer,
-  createSqliteStorage: () => createSqliteStorage,
-  createServer: () => createServer,
-  createRateLimiter: () => createRateLimiter,
-  createPostgresStorage: () => createPostgresStorage,
-  SessionManager: () => SessionManager,
-  ServerClock: () => ServerClock,
-  SERVER_HLC_META_KEY: () => SERVER_HLC_META_KEY,
-  ResultCache: () => ResultCache,
-  OpProcessor: () => OpProcessor,
-  MutationError: () => MutationError,
+  BroadcastEngine: () => BroadcastEngine,
   MessageHandler: () => MessageHandler,
-  BroadcastEngine: () => BroadcastEngine
+  MutationError: () => MutationError,
+  OpProcessor: () => OpProcessor,
+  ResultCache: () => ResultCache,
+  SERVER_HLC_META_KEY: () => SERVER_HLC_META_KEY,
+  ServerClock: () => ServerClock,
+  SessionManager: () => SessionManager,
+  createPostgresStorage: () => createPostgresStorage,
+  createRateLimiter: () => createRateLimiter,
+  createServer: () => createServer,
+  createSqliteStorage: () => createSqliteStorage,
+  createSyncServer: () => createSyncServer,
+  defineTable: () => defineTable,
+  drizzleTable: () => drizzleTable,
+  drizzleTxAtomic: () => drizzleTxAtomic,
+  enforceBatchSize: () => enforceBatchSize,
+  enforceClockDrift: () => enforceClockDrift,
+  enforceReadonly: () => enforceReadonly,
+  enforceServerSet: () => enforceServerSet,
+  processOp: () => processOp,
+  resolveConflict: () => resolveConflict,
+  resolveRoomKey: () => resolveRoomKey,
+  stableStringify: () => stableStringify
 });
 module.exports = __toCommonJS(exports_server);
 
@@ -1007,7 +1007,7 @@ class ResultCache {
     for (const row of rows) {
       const rowId = String(row[idField] ?? "");
       if (rowId) {
-        newRows.set(rowId, row);
+        newRows.set(rowId, { ...row });
       }
     }
     const diff = this.diff(oldRows, newRows);
@@ -1027,6 +1027,9 @@ class ResultCache {
     }
     return this.diff(oldRows, newRows);
   }
+  evictRow(clientId, queryName, rowId) {
+    this.cache.get(clientId)?.get(queryName)?.delete(rowId);
+  }
   clear(clientId, queryName) {
     this.cache.get(clientId)?.delete(queryName);
   }
@@ -1140,6 +1143,14 @@ class BroadcastEngine {
         clearTimeout(timer);
     }
   }
+  forgetWriterRow(tableName, clientId, rowId) {
+    const affectedQueries = this.deps.tableDependencyIndex.get(tableName);
+    if (!affectedQueries)
+      return;
+    for (const queryName of affectedQueries) {
+      this.deps.resultCache.evictRow(clientId, queryName, rowId);
+    }
+  }
   async broadcastChanges(tableName, excludeClientId, overrideRoomKey) {
     const affectedQueries = this.deps.tableDependencyIndex.get(tableName);
     if (!affectedQueries)
@@ -1798,6 +1809,8 @@ class OpProcessor {
     if (queryReg.options.broadcast === "eager-durable" && this.storage) {
       await this.storage.applyOp(op.table, op.rowId, mergedRow, colClocks, hlcStr, op.op, payload);
       this.recordBatchWrite(batchCtx, op.table, op.rowId, mergedRow, colClocks, hlcStr);
+    } else if (!this.storage) {
+      this.recordBatchWrite(batchCtx, op.table, op.rowId, mergedRow, colClocks, hlcStr);
     } else {
       const pushed = this.eagerBuffer.push(op.table, bufferEntry, queryReg.options.maxBufferSize);
       this.recordBatchWrite(batchCtx, op.table, op.rowId, mergedRow, colClocks, hlcStr);
@@ -1809,6 +1822,9 @@ class OpProcessor {
         }
       }
     }
+    if (op.op === "delete") {
+      this.deps.forgetWriterRow(op.table, session.clientId, op.rowId);
+    }
     const senderSession = this.sessions.get(session.clientId);
     const senderSub = senderSession?.subscriptions.get(op.table);
     const senderRoomKey = senderSub ? senderSub.roomKey : undefined;
@@ -1898,6 +1914,9 @@ class OpProcessor {
         await this.storage.applyOp(op.table, op.rowId, result.resolvedRow, result.updatedColClocks, op.hlc, op.op, result.resolvedRow);
         this.recordBatchWrite(batchCtx, op.table, op.rowId, result.resolvedRow, result.updatedColClocks, op.hlc);
       }
+      if (op.op === "delete") {
+        this.deps.forgetWriterRow(op.table, session.clientId, op.rowId);
+      }
       if (deferredBroadcastTables) {
         deferredBroadcastTables.add(op.table);
         if (mutateResult?.affected) {
@@ -1925,14 +1944,14 @@ class OpProcessor {
   }
 }
 
-// src/server/ephemeral-manager.ts
+// src/server/ephemeral/memory.ts
 var DEFAULT_MAX_ENTRIES = 1e4;
-function indexKey(room, key, userId) {
-  return `${room}\x00${key}\x00${userId}`;
+function indexKey(room, key, clientId) {
+  return `${room}\x00${key}\x00${clientId}`;
 }
 function parseIndexKey(packed) {
-  const [room, key, userId] = packed.split("\x00");
-  return { room, key, userId };
+  const [room, key, clientId] = packed.split("\x00");
+  return { room, key, clientId };
 }
 
 class EphemeralManager {
@@ -1946,8 +1965,8 @@ class EphemeralManager {
   set(room, key, clientId, userId, data, ttlMs) {
     const roomMap = this.store.get(room) ?? new Map;
     const keyMap = roomMap.get(key) ?? new Map;
-    const isUpdate = keyMap.has(userId);
-    if (!isUpdate && this.entryCount >= this.maxEntries) {
+    const existing = keyMap.get(clientId);
+    if (!existing && this.entryCount >= this.maxEntries) {
       return false;
     }
     const state = {
@@ -1958,17 +1977,28 @@ class EphemeralManager {
       updatedAt: Date.now(),
       ttlMs
     };
-    keyMap.set(userId, state);
+    keyMap.set(clientId, state);
     roomMap.set(key, keyMap);
     this.store.set(room, roomMap);
-    if (!isUpdate) {
+    if (!existing) {
       this.entryCount++;
-      const clientSet = this.clientIndex.get(clientId) ?? new Set;
-      clientSet.add(indexKey(room, key, userId));
-      this.clientIndex.set(clientId, clientSet);
+      this.addToClientIndex(clientId, indexKey(room, key, clientId));
     }
     return true;
   }
+  addToClientIndex(clientId, packed) {
+    const clientSet = this.clientIndex.get(clientId) ?? new Set;
+    clientSet.add(packed);
+    this.clientIndex.set(clientId, clientSet);
+  }
+  removeFromClientIndex(clientId, packed) {
+    const clientSet = this.clientIndex.get(clientId);
+    if (!clientSet)
+      return;
+    clientSet.delete(packed);
+    if (clientSet.size === 0)
+      this.clientIndex.delete(clientId);
+  }
   get(room, key) {
     const roomMap = this.store.get(room);
     if (!roomMap)
@@ -1978,16 +2008,27 @@ class EphemeralManager {
       return {};
     return Object.fromEntries(keyMap.entries());
   }
-  remove(room, key, userId) {
+  getRoom(room) {
+    const roomMap = this.store.get(room);
+    if (!roomMap)
+      return {};
+    const out = {};
+    for (const [key, keyMap] of roomMap) {
+      out[key] = Object.fromEntries(keyMap.entries());
+    }
+    return out;
+  }
+  remove(room, key, clientId) {
     const roomMap = this.store.get(room);
     if (!roomMap)
       return;
     const keyMap = roomMap.get(key);
     if (!keyMap)
       return;
-    if (keyMap.has(userId)) {
-      keyMap.delete(userId);
+    if (keyMap.has(clientId)) {
+      keyMap.delete(clientId);
       this.entryCount--;
+      this.removeFromClientIndex(clientId, indexKey(room, key, clientId));
     }
     if (keyMap.size === 0) {
       roomMap.delete(key);
@@ -2002,8 +2043,8 @@ class EphemeralManager {
       return;
     const entries = [...indices];
     for (const packed of entries) {
-      const { room, key, userId } = parseIndexKey(packed);
-      this.remove(room, key, userId);
+      const { room, key, clientId: owner } = parseIndexKey(packed);
+      this.remove(room, key, owner);
     }
     this.clientIndex.delete(clientId);
   }
@@ -2012,25 +2053,18 @@ class EphemeralManager {
     const toRemove = [];
     for (const [room, roomMap] of this.store) {
       for (const [key, keyMap] of roomMap) {
-        for (const [userId, state] of keyMap) {
+        for (const [clientId, state] of keyMap) {
           if (state.ttlMs && now - state.updatedAt > state.ttlMs) {
-            toRemove.push({ room, key, userId, clientId: state.clientId });
+            toRemove.push({ room, key, clientId });
           }
         }
       }
     }
-    for (const { room, key, userId, clientId } of toRemove) {
-      this.remove(room, key, userId);
-      const clientSet = this.clientIndex.get(clientId);
-      if (clientSet) {
-        clientSet.delete(indexKey(room, key, userId));
-        if (clientSet.size === 0) {
-          this.clientIndex.delete(clientId);
-        }
-      }
+    for (const { room, key, clientId } of toRemove) {
+      this.remove(room, key, clientId);
     }
   }
-  get size() {
+  size() {
     return this.entryCount;
   }
   destroy() {
@@ -2039,6 +2073,9 @@ class EphemeralManager {
     this.entryCount = 0;
   }
 }
+function createMemoryEphemeral(maxEntries) {
+  return new EphemeralManager(maxEntries);
+}
 
 // src/server/eager-buffer.ts
 var DEFAULT_FLUSH_INTERVAL = 200;
@@ -2483,6 +2520,7 @@ class MessageHandler {
   broadcast;
   ops;
   ephemeralManager = new EphemeralManager;
+  ephemeralBusReady = false;
   ephemeralCleanupTimer = null;
   eagerBuffer = new EagerBuffer;
   replay;
@@ -2553,7 +2591,8 @@ class MessageHandler {
       stampHlc: () => this.clock.stamp(),
       receiveClientHlc: (hlc) => this.clock.receive(hlc),
       send: (clientId, message) => this.transport.send(clientId, message),
-      broadcastChanges: (table, excludeClientId) => this.broadcastChanges(table, excludeClientId)
+      broadcastChanges: (table, excludeClientId) => this.broadcastChanges(table, excludeClientId),
+      forgetWriterRow: (table, clientId, rowId) => this.broadcast.forgetWriterRow(table, clientId, rowId)
     });
     this.transport.onConnect((clientId) => {
       this.sessions.connect(clientId);
@@ -2564,7 +2603,7 @@ class MessageHandler {
       this.messageQueues.delete(clientId);
       this.messageQueueDepths.delete(clientId);
       this.resultCache.clearClient(clientId);
-      this.ephemeralManager.removeClient(clientId);
+      this.forgetEphemeralClient(clientId);
       this.ephemeralBuckets.delete(clientId);
       this.emit({ type: "client_disconnected", clientId });
     });
@@ -2605,7 +2644,9 @@ class MessageHandler {
       this.messageQueues.set(clientId, next);
     });
     this.ephemeralCleanupTimer = setInterval(() => {
-      this.ephemeralManager.cleanupExpired();
+      Promise.resolve(this.ephemeralManager.cleanupExpired()).catch((err) => {
+        console.error("[reflectdb] ephemeral cleanup failed:", err);
+      });
     }, 5000);
     this.eagerBuffer.setOnFlushError((err, op) => {
       this.emit({
@@ -2639,8 +2680,10 @@ class MessageHandler {
       }
       queryNames.add(name);
     }
-    if (registration.options.broadcast === "eager") {
+    if (registration.options.broadcast === "eager" || registration.options.broadcast === "eager-durable") {
       this.eagerBuffer.start(registration.options.flushInterval);
+    }
+    if (registration.options.broadcast === "eager") {
       if (!MessageHandler.eagerWarned) {
         MessageHandler.eagerWarned = true;
         console.warn(`[reflectdb] Query "${name}" uses broadcast: "eager" — at-most-once across server crash for the oplog. ` + `Use "eager-durable" unless your mutate hook writes durably to the user DB and you can tolerate resume-via-snapshot.`);
@@ -2662,6 +2705,26 @@ class MessageHandler {
   setMaxEphemeralEntries(max) {
     this.ephemeralManager = new EphemeralManager(max);
   }
+  setEphemeralAdapter(adapter) {
+    this.ephemeralManager = adapter;
+    if (!adapter.subscribe || this.ephemeralBusReady)
+      return;
+    this.ephemeralBusReady = true;
+    Promise.resolve(adapter.subscribe((event) => {
+      this.deliverRemoteEphemeral(event).catch((err) => {
+        console.error("[reflectdb] remote ephemeral delivery failed:", err);
+      });
+    })).catch((err) => {
+      console.error("[reflectdb] ephemeral bus subscribe failed:", err);
+    });
+  }
+  async forgetEphemeralClient(clientId) {
+    try {
+      await this.ephemeralManager.removeClient(clientId);
+    } catch (err) {
+      console.error("[reflectdb] ephemeral client cleanup failed:", err);
+    }
+  }
   setMinSchemaVersion(version) {
     this.minSchemaVersion = version;
   }
@@ -2686,7 +2749,7 @@ class MessageHandler {
       this.messageQueues.delete(oldest.clientId);
       this.messageQueueDepths.delete(oldest.clientId);
       this.resultCache.clearClient(oldest.clientId);
-      this.ephemeralManager.removeClient(oldest.clientId);
+      await this.forgetEphemeralClient(oldest.clientId);
       this.ephemeralBuckets.delete(oldest.clientId);
     }
   }
@@ -3189,6 +3252,9 @@ class MessageHandler {
       }
     }
     this.sessions.subscribe(clientId, message.table, message.params ?? {}, queryReg.options, roomKey, message.window ?? null);
+    if (roomKey) {
+      await this.sendPresenceSnapshot(clientId, roomKey);
+    }
   }
   async handleLoadMore(clientId, message) {
     const session = this.sessions.get(clientId);
@@ -3302,21 +3368,45 @@ class MessageHandler {
       data,
       ttlMs
     };
-    const sent = new Set;
-    const recipients = [];
     for (const roomKey of roomKeys) {
-      const accepted = this.ephemeralManager.set(roomKey, key, clientId, userId, data, ttlMs);
+      const accepted = await this.ephemeralManager.set(roomKey, key, clientId, userId, data, ttlMs);
       if (!accepted) {
-        this.emit({ type: "ephemeral_full", currentSize: this.ephemeralManager.size });
+        this.emit({
+          type: "ephemeral_full",
+          currentSize: await this.ephemeralManager.size()
+        });
         return;
       }
     }
+    const targets = [];
     for (const queryName of queryNames) {
       const senderSub = session.subscriptions.get(queryName);
-      const senderRoomKey = senderSub?.roomKey ?? null;
-      const subscribers = this.sessions.getSubscribersForQuery(queryName, senderRoomKey);
+      targets.push({ query: queryName, room: senderSub?.roomKey ?? null });
+    }
+    await this.fanOutEphemeral(event, targets, clientId);
+    if (this.ephemeralManager.publish) {
+      try {
+        await this.ephemeralManager.publish({
+          serverId: this.serverId,
+          key,
+          clientId,
+          userId,
+          data,
+          ttlMs,
+          targets
+        });
+      } catch (err) {
+        console.error("[reflectdb] ephemeral publish failed:", err);
+      }
+    }
+  }
+  async fanOutEphemeral(event, targets, exclude) {
+    const sent = new Set;
+    const recipients = [];
+    for (const target of targets) {
+      const subscribers = this.sessions.getSubscribersForQuery(target.query, target.room);
       for (const sub of subscribers) {
-        if (sub.clientId !== clientId && !sent.has(sub.clientId)) {
+        if (sub.clientId !== exclude && !sent.has(sub.clientId)) {
           sent.add(sub.clientId);
           recipients.push(sub.clientId);
         }
@@ -3324,6 +3414,41 @@ class MessageHandler {
     }
     await Promise.all(recipients.map((recipient) => this.trySend(recipient, event)));
   }
+  async deliverRemoteEphemeral(remote) {
+    if (remote.serverId === this.serverId)
+      return;
+    await this.fanOutEphemeral({
+      type: "ephemeral",
+      key: remote.key,
+      clientId: remote.clientId,
+      userId: remote.userId,
+      data: remote.data,
+      ttlMs: remote.ttlMs
+    }, remote.targets);
+  }
+  async sendPresenceSnapshot(clientId, roomKey) {
+    let channels;
+    try {
+      channels = await this.ephemeralManager.getRoom(roomKey);
+    } catch (err) {
+      console.error("[reflectdb] presence snapshot failed:", err);
+      return;
+    }
+    for (const byClient of Object.values(channels)) {
+      for (const state of Object.values(byClient)) {
+        if (state.clientId === clientId)
+          continue;
+        await this.trySend(clientId, {
+          type: "ephemeral",
+          key: state.key,
+          clientId: state.clientId,
+          userId: state.userId,
+          data: state.data,
+          ttlMs: state.ttlMs
+        });
+      }
+    }
+  }
   async reserveOpId(opId) {
     return this.replay.reserve(opId);
   }
@@ -3430,7 +3555,7 @@ class MessageHandler {
     }
     this.messageQueues.clear();
     this.messageQueueDepths.clear();
-    this.ephemeralManager.destroy();
+    Promise.resolve(this.ephemeralManager.destroy()).catch(() => {});
     await this.eagerBuffer.close();
   }
 }
@@ -3505,6 +3630,12 @@ function createServer(config) {
   if (config.storage) {
     handler.setStorage(config.storage);
   }
+  if (config.ephemeral?.maxEntries !== undefined) {
+    handler.setMaxEphemeralEntries(config.ephemeral.maxEntries);
+  }
+  if (config.ephemeral?.adapter) {
+    handler.setEphemeralAdapter(config.ephemeral.adapter);
+  }
   let compactionConfig = null;
   let pollTimer = null;
   const lockChains = new Map;
@@ -3737,7 +3868,7 @@ function createServer(config) {
   return server;
 }
 function registerHotDispose(fn) {
-  if (true) {
+  if (typeof {} !== "undefined") {
     const hot = {}.hot;
     if (hot && typeof hot.dispose === "function") {
       hot.dispose(fn);
@@ -3778,6 +3909,13 @@ function loadDatabase() {
     throw new Error("createSqliteStorage requires the Bun runtime (bun:sqlite is unavailable). Use createPostgresStorage on Node.");
   }
 }
+function withStatement(statement, use) {
+  try {
+    return use(statement);
+  } finally {
+    statement.finalize?.();
+  }
+}
 var OP_ID_RETENTION_MS = 24 * 60 * 60 * 1000;
 function createSqliteStorage(config = {}) {
   const db = config.db ?? new (loadDatabase())(config.path ?? ":memory:");
@@ -3835,6 +3973,18 @@ function createSqliteStorage(config = {}) {
   const cleanupOpsStmt = db.prepare("DELETE FROM _reflectdb_processed_ops WHERE created_at < ?");
   const getMetaStmt = db.prepare("SELECT value FROM _reflectdb_meta WHERE key = ?");
   const setMetaStmt = db.prepare("INSERT OR REPLACE INTO _reflectdb_meta (key, value) VALUES (?, ?)");
+  const persistentStatements = [
+    getRowStmt,
+    putRowStmt,
+    deleteRowStmt,
+    getRowsStmt,
+    appendOpStmt,
+    deleteOpsStmt,
+    reserveOpStmt,
+    cleanupOpsStmt,
+    getMetaStmt,
+    setMetaStmt
+  ];
   return {
     async getRow(table, rowId) {
       const result = getRowStmt.get(table, rowId);
@@ -3851,9 +4001,9 @@ function createSqliteStorage(config = {}) {
       if (rowIds.length === 0)
         return {};
       const placeholders = rowIds.map(() => "?").join(", ");
-      const stmt = db.prepare(`SELECT row_id, data, col_clocks, hlc FROM _reflectdb_rows WHERE tbl = ? AND row_id IN (${placeholders})`);
+      const results = withStatement(db.prepare(`SELECT row_id, data, col_clocks, hlc FROM _reflectdb_rows WHERE tbl = ? AND row_id IN (${placeholders})`), (stmt) => stmt.all(table, ...rowIds));
       const out = {};
-      for (const r of stmt.all(table, ...rowIds)) {
+      for (const r of results) {
         out[r.row_id] = {
           row: JSON.parse(r.data),
           rowHlc: r.hlc,
@@ -3898,8 +4048,7 @@ function createSqliteStorage(config = {}) {
       if (tables.length === 0)
         return [];
       const placeholders = tables.map(() => "?").join(", ");
-      const stmt = db.prepare(`SELECT tbl, op, row_id, payload, hlc, col_clocks FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders}) ORDER BY hlc ASC`);
-      const results = stmt.all(since, ...tables);
+      const results = withStatement(db.prepare(`SELECT tbl, op, row_id, payload, hlc, col_clocks FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders}) ORDER BY hlc ASC`), (stmt) => stmt.all(since, ...tables));
       return results.map((r) => ({
         table: r.tbl,
         op: r.op,
@@ -3913,15 +4062,13 @@ function createSqliteStorage(config = {}) {
       if (tables.length === 0)
         return [];
       const placeholders = tables.map(() => "?").join(", ");
-      const stmt = db.prepare(`SELECT DISTINCT tbl FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders})`);
-      return stmt.all(since, ...tables).map((r) => r.tbl);
+      return withStatement(db.prepare(`SELECT DISTINCT tbl FROM _reflectdb_oplog WHERE hlc > ? AND tbl IN (${placeholders})`), (stmt) => stmt.all(since, ...tables).map((r) => r.tbl));
     },
     async getOplogHead(tables) {
       if (tables.length === 0)
         return null;
       const placeholders = tables.map(() => "?").join(", ");
-      const stmt = db.prepare(`SELECT MAX(hlc) AS head FROM _reflectdb_oplog WHERE tbl IN (${placeholders})`);
-      return stmt.get(...tables)?.head ?? null;
+      return withStatement(db.prepare(`SELECT MAX(hlc) AS head FROM _reflectdb_oplog WHERE tbl IN (${placeholders})`), (stmt) => stmt.get(...tables)?.head ?? null);
     },
     async deleteOpsBefore(hlc) {
       const result = deleteOpsStmt.run(hlc);
@@ -3973,6 +4120,9 @@ function createSqliteStorage(config = {}) {
       db.run("DELETE FROM _reflectdb_meta WHERE key = ?", [`lock:${key}`]);
     },
     close() {
+      for (const statement of persistentStatements) {
+        statement.finalize?.();
+      }
       db.close();
     }
   };
@@ -4246,7 +4396,8 @@ function createSyncServer(config) {
     allowAnonymous: config.allowAnonymous,
     queryTimeoutMs: config.queryTimeoutMs,
     maxBroadcastConcurrency: config.maxBroadcastConcurrency,
-    txAtomic: config.txAtomic
+    txAtomic: config.txAtomic,
+    ephemeral: config.ephemeral
   });
   const implementations = new Map;
   let authCallback = null;