reflectdb 0.1.0 → 0.1.2

package/dist/server/index.js

@@ -1,3 +1,6 @@
+import {
+  EphemeralManager
+} from "../shared/esm-g0marxk7.js";
 import {
   compareHlc,
   createHlc,
@@ -21,7 +24,7 @@ import {
 } from "../shared/esm-3tkwvysa.js";
 import {
   __require
-} from "../shared/esm-b7xs9cde.js";
+} from "../shared/esm-k7kedp3y.js";
 
 // src/server/enforcement.ts
 function enforceClockDrift(hlc) {
@@ -462,7 +465,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);
@@ -482,6 +485,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);
   }
@@ -595,6 +601,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)
@@ -1249,6 +1263,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);
@@ -1260,6 +1276,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;
@@ -1349,6 +1368,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) {
@@ -1376,121 +1398,6 @@ class OpProcessor {
   }
 }
 
-// src/server/ephemeral-manager.ts
-var DEFAULT_MAX_ENTRIES = 1e4;
-function indexKey(room, key, userId) {
-  return `${room}\x00${key}\x00${userId}`;
-}
-function parseIndexKey(packed) {
-  const [room, key, userId] = packed.split("\x00");
-  return { room, key, userId };
-}
-
-class EphemeralManager {
-  store = new Map;
-  clientIndex = new Map;
-  entryCount = 0;
-  maxEntries;
-  constructor(maxEntries) {
-    this.maxEntries = maxEntries ?? DEFAULT_MAX_ENTRIES;
-  }
-  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) {
-      return false;
-    }
-    const state = {
-      clientId,
-      userId,
-      key,
-      data,
-      updatedAt: Date.now(),
-      ttlMs
-    };
-    keyMap.set(userId, state);
-    roomMap.set(key, keyMap);
-    this.store.set(room, roomMap);
-    if (!isUpdate) {
-      this.entryCount++;
-      const clientSet = this.clientIndex.get(clientId) ?? new Set;
-      clientSet.add(indexKey(room, key, userId));
-      this.clientIndex.set(clientId, clientSet);
-    }
-    return true;
-  }
-  get(room, key) {
-    const roomMap = this.store.get(room);
-    if (!roomMap)
-      return {};
-    const keyMap = roomMap.get(key);
-    if (!keyMap)
-      return {};
-    return Object.fromEntries(keyMap.entries());
-  }
-  remove(room, key, userId) {
-    const roomMap = this.store.get(room);
-    if (!roomMap)
-      return;
-    const keyMap = roomMap.get(key);
-    if (!keyMap)
-      return;
-    if (keyMap.has(userId)) {
-      keyMap.delete(userId);
-      this.entryCount--;
-    }
-    if (keyMap.size === 0) {
-      roomMap.delete(key);
-    }
-    if (roomMap.size === 0) {
-      this.store.delete(room);
-    }
-  }
-  removeClient(clientId) {
-    const indices = this.clientIndex.get(clientId);
-    if (!indices)
-      return;
-    const entries = [...indices];
-    for (const packed of entries) {
-      const { room, key, userId } = parseIndexKey(packed);
-      this.remove(room, key, userId);
-    }
-    this.clientIndex.delete(clientId);
-  }
-  cleanupExpired() {
-    const now = Date.now();
-    const toRemove = [];
-    for (const [room, roomMap] of this.store) {
-      for (const [key, keyMap] of roomMap) {
-        for (const [userId, state] of keyMap) {
-          if (state.ttlMs && now - state.updatedAt > state.ttlMs) {
-            toRemove.push({ room, key, userId, clientId: state.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);
-        }
-      }
-    }
-  }
-  get size() {
-    return this.entryCount;
-  }
-  destroy() {
-    this.store.clear();
-    this.clientIndex.clear();
-    this.entryCount = 0;
-  }
-}
-
 // src/server/eager-buffer.ts
 var DEFAULT_FLUSH_INTERVAL = 200;
 var DEFAULT_MAX_BUFFER_SIZE = 1000;
@@ -1934,6 +1841,7 @@ class MessageHandler {
   broadcast;
   ops;
   ephemeralManager = new EphemeralManager;
+  ephemeralBusReady = false;
   ephemeralCleanupTimer = null;
   eagerBuffer = new EagerBuffer;
   replay;
@@ -2004,7 +1912,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);
@@ -2015,7 +1924,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 });
     });
@@ -2056,7 +1965,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({
@@ -2090,8 +2001,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.`);
@@ -2113,6 +2026,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;
   }
@@ -2137,7 +2070,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);
     }
   }
@@ -2640,6 +2573,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);
@@ -2753,21 +2689,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);
         }
@@ -2775,6 +2735,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);
   }
@@ -2881,7 +2876,7 @@ class MessageHandler {
     }
     this.messageQueues.clear();
     this.messageQueueDepths.clear();
-    this.ephemeralManager.destroy();
+    Promise.resolve(this.ephemeralManager.destroy()).catch(() => {});
     await this.eagerBuffer.close();
   }
 }
@@ -2956,6 +2951,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;
@@ -3225,6 +3226,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:");
@@ -3282,6 +3290,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);
@@ -3298,9 +3318,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,
@@ -3345,8 +3365,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,
@@ -3360,15 +3379,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);
@@ -3420,6 +3437,9 @@ function createSqliteStorage(config = {}) {
       db.run("DELETE FROM _reflectdb_meta WHERE key = ?", [`lock:${key}`]);
     },
     close() {
+      for (const statement of persistentStatements) {
+        statement.finalize?.();
+      }
       db.close();
     }
   };
@@ -3693,7 +3713,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;
@@ -3758,7 +3779,7 @@ function createSyncServer(config) {
       server.query(name, fn, {
         tables,
         mutate: async () => {
-          const { MutationError: MutationError2 } = await import("../shared/esm-wkwx6bd9.js");
+          const { MutationError: MutationError2 } = await import("../shared/esm-ck88h30s.js");
           throw new MutationError2("readonly_query", `"${name}" is a view and is read-only`);
         }
       });
@@ -3932,28 +3953,28 @@ function applyServerSet(payload, serverSet, ctx) {
   }
 }
 export {
-  stableStringify,
-  resolveRoomKey,
-  resolveConflict,
-  processOp,
-  enforceServerSet,
-  enforceReadonly,
-  enforceClockDrift,
-  enforceBatchSize,
-  drizzleTxAtomic,
-  drizzleTable,
-  defineTable,
-  createSyncServer,
-  createSqliteStorage,
-  createServer,
-  createRateLimiter,
-  createPostgresStorage,
-  SessionManager,
-  ServerClock,
-  SERVER_HLC_META_KEY,
-  ResultCache,
-  OpProcessor,
-  MutationError,
+  BroadcastEngine,
   MessageHandler,
-  BroadcastEngine
+  MutationError,
+  OpProcessor,
+  ResultCache,
+  SERVER_HLC_META_KEY,
+  ServerClock,
+  SessionManager,
+  createPostgresStorage,
+  createRateLimiter,
+  createServer,
+  createSqliteStorage,
+  createSyncServer,
+  defineTable,
+  drizzleTable,
+  drizzleTxAtomic,
+  enforceBatchSize,
+  enforceClockDrift,
+  enforceReadonly,
+  enforceServerSet,
+  processOp,
+  resolveConflict,
+  resolveRoomKey,
+  stableStringify
 };

package/dist/shared/{esm-ytrd3hbq.js → esm-8qbr4y0d.js}

@@ -256,7 +256,7 @@ class ClientStore {
       if (existing?.serverHlc && compareHlc(hlc, existing.serverHlc) <= 0) {
         return;
       }
-      this.setRow(table, rowId, payload ?? {}, colClocks ?? { _row: hlc }, hlc);
+      this.setRow(table, rowId, this.withPk(table, rowId, payload ?? {}), colClocks ?? { _row: hlc }, hlc);
       return;
     }
     const incomingClocks = colClocks ?? {};
@@ -277,7 +277,13 @@ class ClientStore {
     }
     const newRowHlc = existing.serverHlc && compareHlc(existing.serverHlc, hlc) >= 0 ? existing.serverHlc : hlc;
     mergedClocks._row = newRowHlc;
-    this.setRow(table, rowId, mergedData, mergedClocks, newRowHlc);
+    this.setRow(table, rowId, this.withPk(table, rowId, mergedData), mergedClocks, newRowHlc);
+  }
+  withPk(table, rowId, data) {
+    const pk = this.tableMeta.get(table)?.pk ?? "id";
+    if (data[pk] !== undefined)
+      return data;
+    return { ...data, [pk]: rowId };
   }
   revertOp(opId, serverRow) {
     const pending = this.pendingOps.find((p) => p.op.id === opId);
@@ -322,10 +328,19 @@ class ClientStore {
         delete payload[field];
       }
     }
+    if (op.op === "insert" && payload) {
+      payload = this.withPk(op.table, op.rowId, payload);
+    }
     if (op.op === "delete") {
       this.setRow(op.table, op.rowId, null, { _row: op.hlc }, op.hlc);
     } else if (op.op === "insert") {
-      this.setRow(op.table, op.rowId, payload ?? {}, { _row: op.hlc }, op.hlc);
+      const existing = this.getRow(op.table, op.rowId);
+      if (existing?.data) {
+        const merged = { ...existing.data, ...payload };
+        this.setRow(op.table, op.rowId, merged, existing.colClocks, existing.serverHlc);
+      } else {
+        this.setRow(op.table, op.rowId, payload ?? {}, { _row: op.hlc }, op.hlc);
+      }
     } else {
       const existing = this.getRow(op.table, op.rowId);
       if (existing?.data) {

package/dist/shared/{esm-wkwx6bd9.js → esm-ck88h30s.js}

@@ -10,16 +10,16 @@ import {
   isErrorReason,
   reasonFromError
 } from "./esm-3tkwvysa.js";
-import"./esm-b7xs9cde.js";
+import"./esm-k7kedp3y.js";
 export {
-  reasonFromError,
-  isErrorReason,
-  TransportSendError,
-  TOMBSTONE_RETENTION_MS,
-  SUPPORTED_PROTOCOL_VERSIONS,
-  SERVER_TOMBSTONE_RETENTION_MS,
-  PROTOCOL_VERSION,
-  MutationError,
+  MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS,
-  MAX_BATCH_SIZE
+  MutationError,
+  PROTOCOL_VERSION,
+  SERVER_TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS,
+  TOMBSTONE_RETENTION_MS,
+  TransportSendError,
+  isErrorReason,
+  reasonFromError
 };