@topgunbuild/client 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1384 @@
+// src/SyncEngine.ts
+import { HLC, LWWMap, ORMap, serialize, deserialize, evaluatePredicate } from "@topgunbuild/core";
+
+// src/utils/logger.ts
+import pino from "pino";
+var isBrowser = typeof window !== "undefined";
+var logLevel = typeof process !== "undefined" && process.env && process.env.LOG_LEVEL || "info";
+var logger = pino({
+  level: logLevel,
+  transport: !isBrowser && (typeof process !== "undefined" && process.env.NODE_ENV !== "production") ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
+    }
+  } : void 0,
+  browser: {
+    asObject: true
+  }
+});
+
+// src/SyncEngine.ts
+var SyncEngine = class {
+  constructor(config) {
+    this.websocket = null;
+    this.isOnline = false;
+    this.isAuthenticated = false;
+    this.opLog = [];
+    this.maps = /* @__PURE__ */ new Map();
+    this.queries = /* @__PURE__ */ new Map();
+    this.topics = /* @__PURE__ */ new Map();
+    this.pendingLockRequests = /* @__PURE__ */ new Map();
+    this.lastSyncTimestamp = 0;
+    this.reconnectTimer = null;
+    // NodeJS.Timeout
+    this.authToken = null;
+    this.tokenProvider = null;
+    this.nodeId = config.nodeId;
+    this.serverUrl = config.serverUrl;
+    this.storageAdapter = config.storageAdapter;
+    this.reconnectInterval = config.reconnectInterval || 5e3;
+    this.hlc = new HLC(this.nodeId);
+    this.initConnection();
+    this.loadOpLog();
+  }
+  initConnection() {
+    this.websocket = new WebSocket(this.serverUrl);
+    this.websocket.binaryType = "arraybuffer";
+    this.websocket.onopen = () => {
+      if (this.authToken || this.tokenProvider) {
+        logger.info("WebSocket connected. Sending auth...");
+        this.isOnline = true;
+        this.sendAuth();
+      } else {
+        logger.info("WebSocket connected. Waiting for auth token...");
+        this.isOnline = true;
+      }
+    };
+    this.websocket.onmessage = (event) => {
+      let message;
+      if (event.data instanceof ArrayBuffer) {
+        message = deserialize(new Uint8Array(event.data));
+      } else {
+        try {
+          message = JSON.parse(event.data);
+        } catch (e) {
+          logger.error({ err: e }, "Failed to parse message");
+          return;
+        }
+      }
+      this.handleServerMessage(message);
+    };
+    this.websocket.onclose = () => {
+      logger.info("WebSocket disconnected. Retrying...");
+      this.isOnline = false;
+      this.isAuthenticated = false;
+      this.scheduleReconnect();
+    };
+    this.websocket.onerror = (error) => {
+      logger.error({ err: error }, "WebSocket error");
+    };
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      this.initConnection();
+    }, this.reconnectInterval);
+  }
+  async loadOpLog() {
+    const storedTimestamp = await this.storageAdapter.getMeta("lastSyncTimestamp");
+    if (storedTimestamp) {
+      this.lastSyncTimestamp = storedTimestamp;
+    }
+    const pendingOps = await this.storageAdapter.getPendingOps();
+    this.opLog = pendingOps.map((op) => ({
+      ...op,
+      id: String(op.id),
+      synced: false
+    }));
+    if (this.opLog.length > 0) {
+      logger.info({ count: this.opLog.length }, "Loaded pending operations from local storage");
+    }
+  }
+  async saveOpLog() {
+    await this.storageAdapter.setMeta("lastSyncTimestamp", this.lastSyncTimestamp);
+  }
+  registerMap(mapName, map) {
+    this.maps.set(mapName, map);
+  }
+  async recordOperation(mapName, opType, key, data) {
+    const opLogEntry = {
+      mapName,
+      opType,
+      key,
+      record: data.record,
+      orRecord: data.orRecord,
+      orTag: data.orTag,
+      timestamp: data.timestamp,
+      synced: false
+    };
+    const id = await this.storageAdapter.appendOpLog(opLogEntry);
+    opLogEntry.id = String(id);
+    this.opLog.push(opLogEntry);
+    if (this.isOnline && this.isAuthenticated) {
+      this.syncPendingOperations();
+    }
+  }
+  syncPendingOperations() {
+    const pending = this.opLog.filter((op) => !op.synced);
+    if (pending.length === 0) return;
+    logger.info({ count: pending.length }, "Syncing pending operations");
+    if (this.websocket?.readyState === WebSocket.OPEN) {
+      this.websocket.send(serialize({
+        type: "OP_BATCH",
+        payload: {
+          ops: pending
+        }
+      }));
+    }
+  }
+  startMerkleSync() {
+    for (const [mapName, map] of this.maps) {
+      if (map instanceof LWWMap) {
+        logger.info({ mapName }, "Starting Merkle sync for map");
+        this.websocket?.send(serialize({
+          type: "SYNC_INIT",
+          mapName,
+          lastSyncTimestamp: this.lastSyncTimestamp
+        }));
+      }
+    }
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+    this.tokenProvider = null;
+    if (this.isOnline) {
+      this.sendAuth();
+    } else {
+      if (this.reconnectTimer) {
+        logger.info("Auth token set during backoff. Reconnecting immediately.");
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.initConnection();
+      }
+    }
+  }
+  setTokenProvider(provider) {
+    this.tokenProvider = provider;
+    if (this.isOnline && !this.isAuthenticated) {
+      this.sendAuth();
+    }
+  }
+  async sendAuth() {
+    if (this.tokenProvider) {
+      try {
+        const token2 = await this.tokenProvider();
+        if (token2) {
+          this.authToken = token2;
+        }
+      } catch (err) {
+        logger.error({ err }, "Failed to get token from provider");
+        return;
+      }
+    }
+    const token = this.authToken;
+    if (!token) return;
+    this.websocket?.send(serialize({
+      type: "AUTH",
+      token
+    }));
+  }
+  subscribeToQuery(query) {
+    this.queries.set(query.id, query);
+    if (this.isOnline && this.isAuthenticated) {
+      this.sendQuerySubscription(query);
+    }
+  }
+  subscribeToTopic(topic, handle) {
+    this.topics.set(topic, handle);
+    if (this.isOnline && this.isAuthenticated) {
+      this.sendTopicSubscription(topic);
+    }
+  }
+  unsubscribeFromTopic(topic) {
+    this.topics.delete(topic);
+    if (this.isOnline && this.isAuthenticated) {
+      this.websocket?.send(serialize({
+        type: "TOPIC_UNSUB",
+        payload: { topic }
+      }));
+    }
+  }
+  publishTopic(topic, data) {
+    if (this.isOnline && this.isAuthenticated) {
+      this.websocket?.send(serialize({
+        type: "TOPIC_PUB",
+        payload: { topic, data }
+      }));
+    } else {
+      logger.warn({ topic }, "Dropped topic publish (offline)");
+    }
+  }
+  sendTopicSubscription(topic) {
+    this.websocket?.send(serialize({
+      type: "TOPIC_SUB",
+      payload: { topic }
+    }));
+  }
+  /**
+   * Executes a query against local storage immediately
+   */
+  async runLocalQuery(mapName, filter) {
+    const keys = await this.storageAdapter.getAllKeys();
+    const mapKeys = keys.filter((k) => k.startsWith(mapName + ":"));
+    const results = [];
+    for (const fullKey of mapKeys) {
+      const record = await this.storageAdapter.get(fullKey);
+      if (record && record.value) {
+        const actualKey = fullKey.slice(mapName.length + 1);
+        let matches = true;
+        if (filter.where) {
+          for (const [k, v] of Object.entries(filter.where)) {
+            if (record.value[k] !== v) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (matches && filter.predicate) {
+          if (!evaluatePredicate(filter.predicate, record.value)) {
+            matches = false;
+          }
+        }
+        if (matches) {
+          results.push({ key: actualKey, value: record.value });
+        }
+      }
+    }
+    return results;
+  }
+  unsubscribeFromQuery(queryId) {
+    this.queries.delete(queryId);
+    if (this.isOnline && this.isAuthenticated) {
+      this.websocket?.send(serialize({
+        type: "QUERY_UNSUB",
+        payload: { queryId }
+      }));
+    }
+  }
+  sendQuerySubscription(query) {
+    this.websocket?.send(serialize({
+      type: "QUERY_SUB",
+      payload: {
+        queryId: query.id,
+        mapName: query.getMapName(),
+        query: query.getFilter()
+      }
+    }));
+  }
+  requestLock(name, requestId, ttl) {
+    if (!this.isOnline || !this.isAuthenticated) {
+      return Promise.reject(new Error("Not connected or authenticated"));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pendingLockRequests.has(requestId)) {
+          this.pendingLockRequests.delete(requestId);
+          reject(new Error("Lock request timed out waiting for server response"));
+        }
+      }, 3e4);
+      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
+      try {
+        this.websocket?.send(serialize({
+          type: "LOCK_REQUEST",
+          payload: { requestId, name, ttl }
+        }));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingLockRequests.delete(requestId);
+        reject(e);
+      }
+    });
+  }
+  releaseLock(name, requestId, fencingToken) {
+    if (!this.isOnline) return Promise.resolve(false);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pendingLockRequests.has(requestId)) {
+          this.pendingLockRequests.delete(requestId);
+          resolve(false);
+        }
+      }, 5e3);
+      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
+      try {
+        this.websocket?.send(serialize({
+          type: "LOCK_RELEASE",
+          payload: { requestId, name, fencingToken }
+        }));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingLockRequests.delete(requestId);
+        resolve(false);
+      }
+    });
+  }
+  async handleServerMessage(message) {
+    switch (message.type) {
+      case "AUTH_REQUIRED":
+        this.sendAuth();
+        break;
+      case "AUTH_ACK": {
+        logger.info("Authenticated successfully");
+        const wasAuthenticated = this.isAuthenticated;
+        this.isAuthenticated = true;
+        this.syncPendingOperations();
+        if (!wasAuthenticated) {
+          this.startMerkleSync();
+          for (const query of this.queries.values()) {
+            this.sendQuerySubscription(query);
+          }
+          for (const topic of this.topics.keys()) {
+            this.sendTopicSubscription(topic);
+          }
+        }
+        break;
+      }
+      case "AUTH_FAIL":
+        logger.error({ error: message.error }, "Authentication failed");
+        this.isAuthenticated = false;
+        this.authToken = null;
+        break;
+      case "OP_ACK": {
+        const { lastId } = message.payload;
+        logger.info({ lastId }, "Received ACK for ops");
+        let maxSyncedId = -1;
+        this.opLog.forEach((op) => {
+          if (op.id && op.id <= lastId) {
+            op.synced = true;
+            const idNum = parseInt(op.id, 10);
+            if (!isNaN(idNum) && idNum > maxSyncedId) {
+              maxSyncedId = idNum;
+            }
+          }
+        });
+        if (maxSyncedId !== -1) {
+          this.storageAdapter.markOpsSynced(maxSyncedId).catch((err) => logger.error({ err }, "Failed to mark ops synced"));
+        }
+        break;
+      }
+      case "LOCK_GRANTED": {
+        const { requestId, fencingToken } = message.payload;
+        const req = this.pendingLockRequests.get(requestId);
+        if (req) {
+          clearTimeout(req.timer);
+          this.pendingLockRequests.delete(requestId);
+          req.resolve({ fencingToken });
+        }
+        break;
+      }
+      case "LOCK_RELEASED": {
+        const { requestId, success } = message.payload;
+        const req = this.pendingLockRequests.get(requestId);
+        if (req) {
+          clearTimeout(req.timer);
+          this.pendingLockRequests.delete(requestId);
+          req.resolve(success);
+        }
+        break;
+      }
+      case "QUERY_RESP": {
+        const { queryId, results } = message.payload;
+        const query = this.queries.get(queryId);
+        if (query) {
+          query.onResult(results, "server");
+        }
+        break;
+      }
+      case "QUERY_UPDATE": {
+        const { queryId, key, value, type } = message.payload;
+        const query = this.queries.get(queryId);
+        if (query) {
+          query.onUpdate(key, type === "REMOVE" ? null : value);
+        }
+        break;
+      }
+      case "SERVER_EVENT": {
+        const { mapName, eventType, key, record, orRecord, orTag } = message.payload;
+        const localMap = this.maps.get(mapName);
+        if (localMap) {
+          if (localMap instanceof LWWMap && record) {
+            localMap.merge(key, record);
+            await this.storageAdapter.put(`${mapName}:${key}`, record);
+          } else if (localMap instanceof ORMap) {
+            if (eventType === "OR_ADD" && orRecord) {
+              localMap.apply(key, orRecord);
+            } else if (eventType === "OR_REMOVE" && orTag) {
+              localMap.applyTombstone(orTag);
+            }
+          }
+        }
+        break;
+      }
+      case "TOPIC_MESSAGE": {
+        const { topic, data, publisherId, timestamp } = message.payload;
+        const handle = this.topics.get(topic);
+        if (handle) {
+          handle.onMessage(data, { publisherId, timestamp });
+        }
+        break;
+      }
+      case "GC_PRUNE": {
+        const { olderThan } = message.payload;
+        logger.info({ olderThan: olderThan.millis }, "Received GC_PRUNE request");
+        for (const [name, map] of this.maps) {
+          if (map instanceof LWWMap) {
+            const removedKeys = map.prune(olderThan);
+            for (const key of removedKeys) {
+              await this.storageAdapter.remove(`${name}:${key}`);
+            }
+            if (removedKeys.length > 0) {
+              logger.info({ mapName: name, count: removedKeys.length }, "Pruned tombstones from LWWMap");
+            }
+          } else if (map instanceof ORMap) {
+            const removedTags = map.prune(olderThan);
+            if (removedTags.length > 0) {
+              logger.info({ mapName: name, count: removedTags.length }, "Pruned tombstones from ORMap");
+            }
+          }
+        }
+        break;
+      }
+      case "SYNC_RESET_REQUIRED": {
+        const { mapName } = message.payload;
+        logger.warn({ mapName }, "Sync Reset Required due to GC Age");
+        await this.resetMap(mapName);
+        this.websocket?.send(serialize({
+          type: "SYNC_INIT",
+          mapName,
+          lastSyncTimestamp: 0
+        }));
+        break;
+      }
+      case "SYNC_RESP_ROOT": {
+        const { mapName, rootHash, timestamp } = message.payload;
+        const map = this.maps.get(mapName);
+        if (map instanceof LWWMap) {
+          const localRootHash = map.getMerkleTree().getRootHash();
+          if (localRootHash !== rootHash) {
+            logger.info({ mapName, localRootHash, remoteRootHash: rootHash }, "Root hash mismatch, requesting buckets");
+            this.websocket?.send(serialize({
+              type: "MERKLE_REQ_BUCKET",
+              payload: { mapName, path: "" }
+            }));
+          } else {
+            logger.info({ mapName }, "Map is in sync");
+          }
+        }
+        if (timestamp) {
+          this.hlc.update(timestamp);
+          this.lastSyncTimestamp = timestamp.millis;
+          await this.saveOpLog();
+        }
+        break;
+      }
+      case "SYNC_RESP_BUCKETS": {
+        const { mapName, path, buckets } = message.payload;
+        const map = this.maps.get(mapName);
+        if (map instanceof LWWMap) {
+          const tree = map.getMerkleTree();
+          const localBuckets = tree.getBuckets(path);
+          for (const [bucketKey, remoteHash] of Object.entries(buckets)) {
+            const localHash = localBuckets[bucketKey] || 0;
+            if (localHash !== remoteHash) {
+              const newPath = path + bucketKey;
+              this.websocket?.send(serialize({
+                type: "MERKLE_REQ_BUCKET",
+                payload: { mapName, path: newPath }
+              }));
+            }
+          }
+        }
+        break;
+      }
+      case "SYNC_RESP_LEAF": {
+        const { mapName, records } = message.payload;
+        const map = this.maps.get(mapName);
+        if (map instanceof LWWMap) {
+          let updateCount = 0;
+          for (const { key, record } of records) {
+            const updated = map.merge(key, record);
+            if (updated) {
+              updateCount++;
+              await this.storageAdapter.put(`${mapName}:${key}`, record);
+            }
+          }
+          if (updateCount > 0) {
+            logger.info({ mapName, count: updateCount }, "Synced records from server");
+          }
+        }
+        break;
+      }
+    }
+    if (message.timestamp) {
+      this.hlc.update(message.timestamp);
+      this.lastSyncTimestamp = message.timestamp.millis;
+      await this.saveOpLog();
+    }
+  }
+  getHLC() {
+    return this.hlc;
+  }
+  /**
+   * Closes the WebSocket connection and cleans up resources.
+   */
+  close() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.websocket) {
+      this.websocket.onclose = null;
+      this.websocket.close();
+      this.websocket = null;
+    }
+    this.isOnline = false;
+    this.isAuthenticated = false;
+    logger.info("SyncEngine closed");
+  }
+  async resetMap(mapName) {
+    const map = this.maps.get(mapName);
+    if (map) {
+      if (map instanceof LWWMap) {
+        map.clear();
+      } else if (map instanceof ORMap) {
+        map.clear();
+      }
+    }
+    const allKeys = await this.storageAdapter.getAllKeys();
+    const mapKeys = allKeys.filter((k) => k.startsWith(mapName + ":"));
+    for (const key of mapKeys) {
+      await this.storageAdapter.remove(key);
+    }
+    logger.info({ mapName, removedStorageCount: mapKeys.length }, "Reset map: Cleared memory and storage");
+  }
+};
+
+// src/TopGunClient.ts
+import { LWWMap as LWWMap2, ORMap as ORMap2 } from "@topgunbuild/core";
+
+// src/QueryHandle.ts
+var QueryHandle = class {
+  constructor(syncEngine, mapName, filter = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentResults = /* @__PURE__ */ new Map();
+    // Track if we've received authoritative server response
+    this.hasReceivedServerData = false;
+    this.id = crypto.randomUUID();
+    this.syncEngine = syncEngine;
+    this.mapName = mapName;
+    this.filter = filter;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    if (this.listeners.size === 1) {
+      this.syncEngine.subscribeToQuery(this);
+    } else {
+      callback(this.getSortedResults());
+    }
+    this.loadInitialLocalData().then((data) => {
+      if (this.currentResults.size === 0) {
+        this.onResult(data, "local");
+      }
+    });
+    return () => {
+      this.listeners.delete(callback);
+      if (this.listeners.size === 0) {
+        this.syncEngine.unsubscribeFromQuery(this.id);
+      }
+    };
+  }
+  async loadInitialLocalData() {
+    return this.syncEngine.runLocalQuery(this.mapName, this.filter);
+  }
+  /**
+   * Called by SyncEngine when server sends initial results or by local storage load.
+   * Uses merge strategy instead of clear to prevent UI flickering.
+   *
+   * @param items - Array of key-value pairs
+   * @param source - 'local' for IndexedDB data, 'server' for QUERY_RESP from server
+   *
+   * Race condition protection:
+   * - Empty server responses are ignored until we receive non-empty server data
+   * - This prevents clearing local data when server hasn't loaded from storage yet
+   * - Works with any async storage adapter (PostgreSQL, SQLite, Redis, etc.)
+   */
+  onResult(items, source = "server") {
+    console.log(`[QueryHandle:${this.mapName}] onResult called with ${items.length} items`, {
+      source,
+      currentResultsCount: this.currentResults.size,
+      newItemKeys: items.map((i) => i.key),
+      hasReceivedServerData: this.hasReceivedServerData
+    });
+    if (source === "server" && items.length === 0 && !this.hasReceivedServerData) {
+      console.log(`[QueryHandle:${this.mapName}] Ignoring empty server response - waiting for authoritative data`);
+      return;
+    }
+    if (source === "server" && items.length > 0) {
+      this.hasReceivedServerData = true;
+    }
+    const newKeys = new Set(items.map((i) => i.key));
+    const removedKeys = [];
+    for (const key of this.currentResults.keys()) {
+      if (!newKeys.has(key)) {
+        removedKeys.push(key);
+        this.currentResults.delete(key);
+      }
+    }
+    if (removedKeys.length > 0) {
+      console.log(`[QueryHandle:${this.mapName}] Removed ${removedKeys.length} keys:`, removedKeys);
+    }
+    for (const item of items) {
+      this.currentResults.set(item.key, item.value);
+    }
+    console.log(`[QueryHandle:${this.mapName}] After merge: ${this.currentResults.size} results`);
+    this.notify();
+  }
+  /**
+   * Called by SyncEngine when server sends a live update
+   */
+  onUpdate(key, value) {
+    if (value === null) {
+      this.currentResults.delete(key);
+    } else {
+      this.currentResults.set(key, value);
+    }
+    this.notify();
+  }
+  notify() {
+    const results = this.getSortedResults();
+    for (const listener of this.listeners) {
+      listener(results);
+    }
+  }
+  getSortedResults() {
+    const results = Array.from(this.currentResults.entries()).map(
+      ([key, value]) => ({ ...value, _key: key })
+    );
+    if (this.filter.sort) {
+      results.sort((a, b) => {
+        for (const [field, direction] of Object.entries(this.filter.sort)) {
+          const valA = a[field];
+          const valB = b[field];
+          if (valA < valB) return direction === "asc" ? -1 : 1;
+          if (valA > valB) return direction === "asc" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    return results;
+  }
+  getFilter() {
+    return this.filter;
+  }
+  getMapName() {
+    return this.mapName;
+  }
+};
+
+// src/DistributedLock.ts
+var DistributedLock = class {
+  constructor(syncEngine, name) {
+    this.fencingToken = null;
+    this._isLocked = false;
+    this.syncEngine = syncEngine;
+    this.name = name;
+  }
+  async lock(ttl = 1e4) {
+    const requestId = crypto.randomUUID();
+    try {
+      const result = await this.syncEngine.requestLock(this.name, requestId, ttl);
+      this.fencingToken = result.fencingToken;
+      this._isLocked = true;
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async unlock() {
+    if (!this._isLocked || this.fencingToken === null) return;
+    const requestId = crypto.randomUUID();
+    try {
+      await this.syncEngine.releaseLock(this.name, requestId, this.fencingToken);
+    } finally {
+      this._isLocked = false;
+      this.fencingToken = null;
+    }
+  }
+  isLocked() {
+    return this._isLocked;
+  }
+};
+
+// src/TopicHandle.ts
+var TopicHandle = class {
+  constructor(engine, topic) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.engine = engine;
+    this.topic = topic;
+  }
+  get id() {
+    return this.topic;
+  }
+  /**
+   * Publish a message to the topic
+   */
+  publish(data) {
+    this.engine.publishTopic(this.topic, data);
+  }
+  /**
+   * Subscribe to the topic
+   */
+  subscribe(callback) {
+    if (this.listeners.size === 0) {
+      this.engine.subscribeToTopic(this.topic, this);
+    }
+    this.listeners.add(callback);
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+    if (this.listeners.size === 0) {
+      this.engine.unsubscribeFromTopic(this.topic);
+    }
+  }
+  /**
+   * Called by SyncEngine when a message is received
+   */
+  onMessage(data, context) {
+    this.listeners.forEach((cb) => {
+      try {
+        cb(data, context);
+      } catch (e) {
+        console.error("Error in topic listener", e);
+      }
+    });
+  }
+};
+
+// src/TopGunClient.ts
+var TopGunClient = class {
+  constructor(config) {
+    this.maps = /* @__PURE__ */ new Map();
+    this.topicHandles = /* @__PURE__ */ new Map();
+    this.nodeId = config.nodeId || crypto.randomUUID();
+    this.storageAdapter = config.storage;
+    const syncEngineConfig = {
+      nodeId: this.nodeId,
+      serverUrl: config.serverUrl,
+      storageAdapter: this.storageAdapter
+    };
+    this.syncEngine = new SyncEngine(syncEngineConfig);
+  }
+  async start() {
+    await this.storageAdapter.initialize("topgun_offline_db");
+  }
+  setAuthToken(token) {
+    this.syncEngine.setAuthToken(token);
+  }
+  setAuthTokenProvider(provider) {
+    this.syncEngine.setTokenProvider(provider);
+  }
+  /**
+   * Creates a live query subscription for a map.
+   */
+  query(mapName, filter) {
+    return new QueryHandle(this.syncEngine, mapName, filter);
+  }
+  /**
+   * Retrieves a distributed lock instance.
+   * @param name The name of the lock.
+   */
+  getLock(name) {
+    return new DistributedLock(this.syncEngine, name);
+  }
+  /**
+   * Retrieves a topic handle for Pub/Sub messaging.
+   * @param name The name of the topic.
+   */
+  topic(name) {
+    if (!this.topicHandles.has(name)) {
+      this.topicHandles.set(name, new TopicHandle(this.syncEngine, name));
+    }
+    return this.topicHandles.get(name);
+  }
+  /**
+   * Retrieves an LWWMap instance. If the map doesn't exist locally, it's created.
+   * @param name The name of the map.
+   * @returns An LWWMap instance.
+   */
+  getMap(name) {
+    if (this.maps.has(name)) {
+      const map = this.maps.get(name);
+      if (map instanceof LWWMap2) {
+        return map;
+      }
+      throw new Error(`Map ${name} exists but is not an LWWMap`);
+    }
+    const lwwMap = new LWWMap2(this.syncEngine.getHLC());
+    this.maps.set(name, lwwMap);
+    this.syncEngine.registerMap(name, lwwMap);
+    this.storageAdapter.getAllKeys().then(async (keys) => {
+      const mapPrefix = `${name}:`;
+      for (const fullKey of keys) {
+        if (fullKey.startsWith(mapPrefix)) {
+          const record = await this.storageAdapter.get(fullKey);
+          if (record && record.timestamp && !record.tag) {
+            const key = fullKey.substring(mapPrefix.length);
+            lwwMap.merge(key, record);
+          }
+        }
+      }
+    }).catch((err) => logger.error({ err }, "Failed to restore keys from storage"));
+    const originalSet = lwwMap.set.bind(lwwMap);
+    lwwMap.set = (key, value, ttlMs) => {
+      const record = originalSet(key, value, ttlMs);
+      this.storageAdapter.put(`${name}:${key}`, record).catch((err) => logger.error({ err }, "Failed to put record to storage"));
+      this.syncEngine.recordOperation(name, "PUT", String(key), { record, timestamp: record.timestamp }).catch((err) => logger.error({ err }, "Failed to record PUT op"));
+      return record;
+    };
+    const originalRemove = lwwMap.remove.bind(lwwMap);
+    lwwMap.remove = (key) => {
+      const tombstone = originalRemove(key);
+      this.storageAdapter.put(`${name}:${key}`, tombstone).catch((err) => logger.error({ err }, "Failed to put tombstone to storage"));
+      this.syncEngine.recordOperation(name, "REMOVE", String(key), { record: tombstone, timestamp: tombstone.timestamp }).catch((err) => logger.error({ err }, "Failed to record REMOVE op"));
+      return tombstone;
+    };
+    return lwwMap;
+  }
+  /**
+   * Retrieves an ORMap instance. If the map doesn't exist locally, it's created.
+   * @param name The name of the map.
+   * @returns An ORMap instance.
+   */
+  getORMap(name) {
+    if (this.maps.has(name)) {
+      const map = this.maps.get(name);
+      if (map instanceof ORMap2) {
+        return map;
+      }
+      throw new Error(`Map ${name} exists but is not an ORMap`);
+    }
+    const orMap = new ORMap2(this.syncEngine.getHLC());
+    this.maps.set(name, orMap);
+    this.syncEngine.registerMap(name, orMap);
+    this.restoreORMap(name, orMap);
+    const originalAdd = orMap.add.bind(orMap);
+    orMap.add = (key, value, ttlMs) => {
+      const record = originalAdd(key, value, ttlMs);
+      this.persistORMapKey(name, orMap, key);
+      this.syncEngine.recordOperation(name, "OR_ADD", String(key), { orRecord: record, timestamp: record.timestamp }).catch((err) => logger.error({ err }, "Failed to record OR_ADD op"));
+      return record;
+    };
+    const originalRemove = orMap.remove.bind(orMap);
+    orMap.remove = (key, value) => {
+      const tombstones = originalRemove(key, value);
+      const timestamp = this.syncEngine.getHLC().now();
+      this.persistORMapKey(name, orMap, key);
+      this.persistORMapTombstones(name, orMap);
+      for (const tag of tombstones) {
+        this.syncEngine.recordOperation(name, "OR_REMOVE", String(key), { orTag: tag, timestamp }).catch((err) => logger.error({ err }, "Failed to record OR_REMOVE op"));
+      }
+      return tombstones;
+    };
+    return orMap;
+  }
+  async restoreORMap(name, orMap) {
+    try {
+      const tombstoneKey = `__sys__:${name}:tombstones`;
+      const tombstones = await this.storageAdapter.getMeta(tombstoneKey);
+      if (Array.isArray(tombstones)) {
+        for (const tag of tombstones) {
+          orMap.applyTombstone(tag);
+        }
+      }
+      const keys = await this.storageAdapter.getAllKeys();
+      const mapPrefix = `${name}:`;
+      for (const fullKey of keys) {
+        if (fullKey.startsWith(mapPrefix)) {
+          const keyPart = fullKey.substring(mapPrefix.length);
+          const data = await this.storageAdapter.get(fullKey);
+          if (Array.isArray(data)) {
+            const records = data;
+            const key = keyPart;
+            for (const record of records) {
+              orMap.apply(key, record);
+            }
+          }
+        }
+      }
+    } catch (e) {
+      logger.error({ mapName: name, err: e }, "Failed to restore ORMap");
+    }
+  }
+  async persistORMapKey(mapName, orMap, key) {
+    const records = orMap.getRecords(key);
+    if (records.length > 0) {
+      await this.storageAdapter.put(`${mapName}:${key}`, records);
+    } else {
+      await this.storageAdapter.remove(`${mapName}:${key}`);
+    }
+  }
+  async persistORMapTombstones(mapName, orMap) {
+    const tombstoneKey = `__sys__:${mapName}:tombstones`;
+    const tombstones = orMap.getTombstones();
+    await this.storageAdapter.setMeta(tombstoneKey, tombstones);
+  }
+  /**
+   * Closes the client, disconnecting from the server and cleaning up resources.
+   */
+  close() {
+    this.syncEngine.close();
+  }
+};
+
+// src/adapters/IDBAdapter.ts
+import { openDB } from "idb";
+var IDBAdapter = class {
+  constructor() {
+    this.isReady = false;
+    this.operationQueue = [];
+  }
+  /**
+   * Initializes IndexedDB in the background.
+   * Returns immediately - does NOT block on IndexedDB being ready.
+   * Use waitForReady() if you need to ensure initialization is complete.
+   */
+  async initialize(dbName) {
+    this.initPromise = this.initializeInternal(dbName);
+  }
+  /**
+   * Internal initialization that actually opens IndexedDB.
+   */
+  async initializeInternal(dbName) {
+    try {
+      this.dbPromise = openDB(dbName, 2, {
+        upgrade(db) {
+          if (!db.objectStoreNames.contains("kv_store")) {
+            db.createObjectStore("kv_store", { keyPath: "key" });
+          }
+          if (!db.objectStoreNames.contains("op_log")) {
+            db.createObjectStore("op_log", { keyPath: "id", autoIncrement: true });
+          }
+          if (!db.objectStoreNames.contains("meta_store")) {
+            db.createObjectStore("meta_store", { keyPath: "key" });
+          }
+        }
+      });
+      this.db = await this.dbPromise;
+      this.isReady = true;
+      await this.flushQueue();
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Waits for IndexedDB to be fully initialized.
+   * Call this if you need guaranteed persistence before proceeding.
+   */
+  async waitForReady() {
+    if (this.isReady) return;
+    if (this.initPromise) {
+      await this.initPromise;
+    }
+  }
+  /**
+   * Flushes all queued operations once IndexedDB is ready.
+   */
+  async flushQueue() {
+    const queue = this.operationQueue;
+    this.operationQueue = [];
+    for (const op of queue) {
+      try {
+        let result;
+        switch (op.type) {
+          case "put":
+            result = await this.putInternal(op.args[0], op.args[1]);
+            break;
+          case "remove":
+            result = await this.removeInternal(op.args[0]);
+            break;
+          case "setMeta":
+            result = await this.setMetaInternal(op.args[0], op.args[1]);
+            break;
+          case "appendOpLog":
+            result = await this.appendOpLogInternal(op.args[0]);
+            break;
+          case "markOpsSynced":
+            result = await this.markOpsSyncedInternal(op.args[0]);
+            break;
+          case "batchPut":
+            result = await this.batchPutInternal(op.args[0]);
+            break;
+        }
+        op.resolve(result);
+      } catch (error) {
+        op.reject(error);
+      }
+    }
+  }
+  /**
+   * Queues an operation if not ready, or executes immediately if ready.
+   */
+  queueOrExecute(type, args, executor) {
+    if (this.isReady) {
+      return executor();
+    }
+    return new Promise((resolve, reject) => {
+      this.operationQueue.push({ type, args, resolve, reject });
+    });
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+  // ============================================
+  // Read Operations - Wait for ready
+  // ============================================
+  async get(key) {
+    await this.waitForReady();
+    const result = await this.db?.get("kv_store", key);
+    return result?.value;
+  }
+  async getMeta(key) {
+    await this.waitForReady();
+    const result = await this.db?.get("meta_store", key);
+    return result?.value;
+  }
+  async getPendingOps() {
+    await this.waitForReady();
+    const all = await this.db?.getAll("op_log");
+    return all?.filter((op) => op.synced === 0) || [];
+  }
+  async getAllKeys() {
+    await this.waitForReady();
+    return await this.db?.getAllKeys("kv_store") || [];
+  }
+  // ============================================
+  // Write Operations - Queue if not ready
+  // ============================================
+  async put(key, value) {
+    return this.queueOrExecute("put", [key, value], () => this.putInternal(key, value));
+  }
+  async putInternal(key, value) {
+    await this.db?.put("kv_store", { key, value });
+  }
+  async remove(key) {
+    return this.queueOrExecute("remove", [key], () => this.removeInternal(key));
+  }
+  async removeInternal(key) {
+    await this.db?.delete("kv_store", key);
+  }
+  async setMeta(key, value) {
+    return this.queueOrExecute("setMeta", [key, value], () => this.setMetaInternal(key, value));
+  }
+  async setMetaInternal(key, value) {
+    await this.db?.put("meta_store", { key, value });
+  }
+  async batchPut(entries) {
+    return this.queueOrExecute("batchPut", [entries], () => this.batchPutInternal(entries));
+  }
+  async batchPutInternal(entries) {
+    const tx = this.db?.transaction("kv_store", "readwrite");
+    if (!tx) return;
+    await Promise.all(
+      Array.from(entries.entries()).map(
+        ([key, value]) => tx.store.put({ key, value })
+      )
+    );
+    await tx.done;
+  }
+  async appendOpLog(entry) {
+    return this.queueOrExecute("appendOpLog", [entry], () => this.appendOpLogInternal(entry));
+  }
+  async appendOpLogInternal(entry) {
+    const entryToSave = { ...entry, synced: 0 };
+    return await this.db?.add("op_log", entryToSave);
+  }
+  async markOpsSynced(lastId) {
+    return this.queueOrExecute("markOpsSynced", [lastId], () => this.markOpsSyncedInternal(lastId));
+  }
+  async markOpsSyncedInternal(lastId) {
+    const tx = this.db?.transaction("op_log", "readwrite");
+    if (!tx) return;
+    let cursor = await tx.store.openCursor();
+    while (cursor) {
+      if (cursor.value.id <= lastId) {
+        const update = { ...cursor.value, synced: 1 };
+        await cursor.update(update);
+      }
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  }
+};
+
+// src/TopGun.ts
+var handler = {
+  get(target, prop, receiver) {
+    if (prop in target || typeof prop === "symbol") {
+      return Reflect.get(target, prop, receiver);
+    }
+    if (typeof prop === "string") {
+      return target.collection(prop);
+    }
+    return void 0;
+  }
+};
+var TopGun = class {
+  constructor(config) {
+    let storage;
+    if (config.persist === "indexeddb") {
+      storage = new IDBAdapter();
+    } else if (typeof config.persist === "object") {
+      storage = config.persist;
+    } else {
+      throw new Error(`Unsupported persist option: ${config.persist}`);
+    }
+    this.client = new TopGunClient({
+      serverUrl: config.sync,
+      storage,
+      nodeId: config.nodeId
+    });
+    this.initPromise = this.client.start().catch((err) => {
+      console.error("Failed to start TopGun client:", err);
+      throw err;
+    });
+    return new Proxy(this, handler);
+  }
+  /**
+   * Waits for the storage adapter to be fully initialized.
+   * This is optional - you can start using the database immediately.
+   * Operations are queued in memory and persisted once IndexedDB is ready.
+   */
+  async waitForReady() {
+    await this.initPromise;
+  }
+  collection(name) {
+    const map = this.client.getMap(name);
+    return new CollectionWrapper(map);
+  }
+};
+var CollectionWrapper = class {
+  constructor(map) {
+    this.map = map;
+  }
+  /**
+   * Sets an item in the collection. 
+   * The item MUST have an 'id' or '_id' field.
+   */
+  async set(value) {
+    const v = value;
+    const key = v.id || v._id;
+    if (!key) {
+      throw new Error('Object must have an "id" or "_id" property to be saved in a collection.');
+    }
+    this.map.set(key, value);
+    return Promise.resolve(value);
+  }
+  /**
+   * Retrieves an item by ID.
+   * Returns the value directly (unwrapped from CRDT record).
+   */
+  get(key) {
+    return this.map.get(key);
+  }
+  /**
+   * Get the raw LWWRecord (including metadata like timestamp).
+   */
+  getRecord(key) {
+    return this.map.getRecord(key);
+  }
+  // Expose raw map if needed for advanced usage
+  get raw() {
+    return this.map;
+  }
+};
+
+// src/crypto/EncryptionManager.ts
+import { serialize as serialize2, deserialize as deserialize2 } from "@topgunbuild/core";
+var _EncryptionManager = class _EncryptionManager {
+  /**
+   * Encrypts data using AES-GCM.
+   * Serializes data to MessagePack before encryption.
+   */
+  static async encrypt(key, data) {
+    const encoded = serialize2(data);
+    const iv = window.crypto.getRandomValues(new Uint8Array(_EncryptionManager.IV_LENGTH));
+    const ciphertext = await window.crypto.subtle.encrypt(
+      {
+        name: _EncryptionManager.ALGORITHM,
+        iv
+      },
+      key,
+      encoded
+    );
+    return {
+      iv,
+      data: new Uint8Array(ciphertext)
+    };
+  }
+  /**
+   * Decrypts AES-GCM encrypted data.
+   * Deserializes from MessagePack after decryption.
+   */
+  static async decrypt(key, record) {
+    try {
+      const plaintextBuffer = await window.crypto.subtle.decrypt(
+        {
+          name: _EncryptionManager.ALGORITHM,
+          iv: record.iv
+        },
+        key,
+        record.data
+      );
+      return deserialize2(new Uint8Array(plaintextBuffer));
+    } catch (err) {
+      console.error("Decryption failed", err);
+      throw new Error("Failed to decrypt data: " + err);
+    }
+  }
+};
+_EncryptionManager.ALGORITHM = "AES-GCM";
+_EncryptionManager.IV_LENGTH = 12;
+var EncryptionManager = _EncryptionManager;
+
+// src/adapters/EncryptedStorageAdapter.ts
+var EncryptedStorageAdapter = class {
+  constructor(wrapped, key) {
+    this.wrapped = wrapped;
+    this.key = key;
+  }
+  async initialize(dbName) {
+    return this.wrapped.initialize(dbName);
+  }
+  async close() {
+    return this.wrapped.close();
+  }
+  // --- KV Operations ---
+  async get(key) {
+    const raw = await this.wrapped.get(key);
+    if (!raw) {
+      return void 0;
+    }
+    if (this.isEncryptedRecord(raw)) {
+      try {
+        return await EncryptionManager.decrypt(this.key, raw);
+      } catch (e) {
+        throw e;
+      }
+    }
+    return raw;
+  }
+  async put(key, value) {
+    const encrypted = await EncryptionManager.encrypt(this.key, value);
+    const storedValue = {
+      iv: encrypted.iv,
+      data: encrypted.data
+    };
+    return this.wrapped.put(key, storedValue);
+  }
+  async remove(key) {
+    return this.wrapped.remove(key);
+  }
+  // --- Metadata ---
+  async getMeta(key) {
+    const raw = await this.wrapped.getMeta(key);
+    if (!raw) return void 0;
+    if (this.isEncryptedRecord(raw)) {
+      return EncryptionManager.decrypt(this.key, raw);
+    }
+    return raw;
+  }
+  async setMeta(key, value) {
+    const encrypted = await EncryptionManager.encrypt(this.key, value);
+    return this.wrapped.setMeta(key, {
+      iv: encrypted.iv,
+      data: encrypted.data
+    });
+  }
+  // --- Batch ---
+  async batchPut(entries) {
+    const encryptedEntries = /* @__PURE__ */ new Map();
+    for (const [key, value] of entries.entries()) {
+      const encrypted = await EncryptionManager.encrypt(this.key, value);
+      encryptedEntries.set(key, {
+        iv: encrypted.iv,
+        data: encrypted.data
+      });
+    }
+    return this.wrapped.batchPut(encryptedEntries);
+  }
+  // --- OpLog ---
+  async appendOpLog(entry) {
+    const encryptedEntry = { ...entry };
+    if (entry.value !== void 0) {
+      const enc = await EncryptionManager.encrypt(this.key, entry.value);
+      encryptedEntry.value = { iv: enc.iv, data: enc.data };
+    }
+    if (entry.record !== void 0) {
+      const enc = await EncryptionManager.encrypt(this.key, entry.record);
+      encryptedEntry.record = { iv: enc.iv, data: enc.data };
+    }
+    if (entry.orRecord !== void 0) {
+      const enc = await EncryptionManager.encrypt(this.key, entry.orRecord);
+      encryptedEntry.orRecord = { iv: enc.iv, data: enc.data };
+    }
+    return this.wrapped.appendOpLog(encryptedEntry);
+  }
+  async getPendingOps() {
+    const ops = await this.wrapped.getPendingOps();
+    return Promise.all(ops.map(async (op) => {
+      const decryptedOp = { ...op };
+      if (this.isEncryptedRecord(op.value)) {
+        decryptedOp.value = await EncryptionManager.decrypt(this.key, op.value);
+      }
+      if (this.isEncryptedRecord(op.record)) {
+        decryptedOp.record = await EncryptionManager.decrypt(this.key, op.record);
+      }
+      if (this.isEncryptedRecord(op.orRecord)) {
+        decryptedOp.orRecord = await EncryptionManager.decrypt(this.key, op.orRecord);
+      }
+      return decryptedOp;
+    }));
+  }
+  async markOpsSynced(lastId) {
+    return this.wrapped.markOpsSynced(lastId);
+  }
+  // --- Iteration ---
+  async getAllKeys() {
+    return this.wrapped.getAllKeys();
+  }
+  // --- Helpers ---
+  isEncryptedRecord(data) {
+    return data && typeof data === "object" && data.iv instanceof Uint8Array && data.data instanceof Uint8Array;
+  }
+};
+
+// src/index.ts
+import { LWWMap as LWWMap3, Predicates } from "@topgunbuild/core";
+export {
+  EncryptedStorageAdapter,
+  IDBAdapter,
+  LWWMap3 as LWWMap,
+  Predicates,
+  QueryHandle,
+  SyncEngine,
+  TopGun,
+  TopGunClient,
+  TopicHandle,
+  logger
+};
+//# sourceMappingURL=index.mjs.map