holosphere 2.0.0-alpha4 → 2.0.0-alpha5

package/dist/{index-CV0eOogK.js → index-Bbey4GkP.js}

@@ -1,4 +1,4 @@
-import { getPublicKey as getPublicKey$2, SimplePool, finalizeEvent, nip19, nip04, verifyEvent as verifyEvent$1 } from "nostr-tools";
+import { getPublicKey as getPublicKey$2, finalizeEvent, SimplePool, nip19, nip04, verifyEvent as verifyEvent$1 } from "nostr-tools";
 import * as h3 from "h3-js";
 import { latLngToCell, getResolution, cellToParent, cellToChildren, isValidCell } from "h3-js";
 import Ajv from "ajv";
@@ -361,17 +361,84 @@ async function createPersistentStorage(namespace, options = {}) {
   const isBrowser = typeof window !== "undefined" && typeof window.indexedDB !== "undefined";
   typeof process !== "undefined" && process.versions && void 0;
   if (isBrowser) {
-    const { IndexedDBStorage } = await import("./indexeddb-storage-DZaGlY_a.js");
+    const { IndexedDBStorage } = await import("./indexeddb-storage-Bjg84U5R.js");
     const storage = new IndexedDBStorage();
     await storage.init(namespace);
     return storage;
   } else {
-    const { MemoryStorage } = await import("./memory-storage-BkUi6sZG.js");
+    const { MemoryStorage } = await import("./memory-storage-CD0XFayE.js");
     const storage = new MemoryStorage();
     await storage.init(namespace);
     return storage;
   }
 }
+let globalPool = null;
+let globalPoolRelays = /* @__PURE__ */ new Set();
+function getGlobalPool(config = {}) {
+  if (!globalPool) {
+    globalPool = new SimplePool({
+      enableReconnect: config.enableReconnect !== false,
+      enablePing: config.enablePing !== false
+    });
+  }
+  return globalPool;
+}
+const pendingQueries$1 = /* @__PURE__ */ new Map();
+const PENDING_QUERY_TIMEOUT = 5e3;
+const activeSubscriptions = /* @__PURE__ */ new Map();
+const backgroundRefreshThrottle = /* @__PURE__ */ new Map();
+const BACKGROUND_REFRESH_INTERVAL = 3e4;
+const pendingWrites = /* @__PURE__ */ new Map();
+const WRITE_DEBOUNCE_MS = 500;
+const authorSubscriptions = /* @__PURE__ */ new Map();
+const AUTHOR_SUB_INIT_TIMEOUT = 5e3;
+class LRUCache {
+  constructor(maxSize = 500) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  values() {
+    return this.cache.values();
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  forEach(callback) {
+    this.cache.forEach(callback);
+  }
+}
 let webSocketPolyfillPromise = null;
 function ensureWebSocket() {
   if (typeof globalThis.WebSocket !== "undefined") {
@@ -407,8 +474,12 @@ class NostrClient {
     this.publicKey = getPublicKey$2(this.privateKey);
     this.config = config;
     this._subscriptions = /* @__PURE__ */ new Map();
-    this._eventCache = /* @__PURE__ */ new Map();
+    this._eventCache = new LRUCache(config.cacheSize || 500);
+    this._cacheIndex = /* @__PURE__ */ new Map();
     this.persistentStorage = null;
+    this._persistQueue = /* @__PURE__ */ new Map();
+    this._persistTimer = null;
+    this._persistBatchMs = config.persistBatchMs || 100;
     this._initReady = this._initialize();
   }
   /**
@@ -418,10 +489,8 @@ class NostrClient {
   async _initialize() {
     await ensureWebSocket();
     if (this.relays.length > 0) {
-      this.pool = new SimplePool({
-        enableReconnect: this.config.enableReconnect !== false,
-        enablePing: this.config.enablePing !== false
-      });
+      this.pool = getGlobalPool(this.config);
+      this.relays.forEach((r) => globalPoolRelays.add(r));
     } else {
       this.pool = {
         publish: (relays, event) => [Promise.resolve()],
@@ -433,6 +502,69 @@ class NostrClient {
       };
     }
     await this._initPersistentStorage();
+    if (this.relays.length > 0) {
+      this._initLongLivedSubscription();
+    }
+  }
+  /**
+   * Initialize a long-lived subscription to keep cache fresh
+   * This replaces polling with a single persistent subscription
+   * @private
+   */
+  _initLongLivedSubscription() {
+    const subKey = this.publicKey;
+    if (authorSubscriptions.has(subKey)) {
+      return;
+    }
+    const subInfo = {
+      subscription: null,
+      initialized: false,
+      initPromise: null,
+      initResolve: null
+    };
+    subInfo.initPromise = new Promise((resolve) => {
+      subInfo.initResolve = resolve;
+    });
+    authorSubscriptions.set(subKey, subInfo);
+    const filter = {
+      kinds: [3e4],
+      authors: [this.publicKey]
+    };
+    const sub = this.pool.subscribeMany(
+      this.relays,
+      [filter],
+      {
+        onevent: (event) => {
+          if (event.pubkey !== this.publicKey) {
+            return;
+          }
+          this._cacheEvent(event);
+        },
+        oneose: () => {
+          if (!subInfo.initialized) {
+            subInfo.initialized = true;
+            subInfo.initResolve();
+          }
+        }
+      }
+    );
+    subInfo.subscription = sub;
+    setTimeout(() => {
+      if (!subInfo.initialized) {
+        subInfo.initialized = true;
+        subInfo.initResolve();
+      }
+    }, AUTHOR_SUB_INIT_TIMEOUT);
+  }
+  /**
+   * Wait for long-lived subscription to complete initial load
+   * @private
+   */
+  async _waitForSubscriptionInit() {
+    const subInfo = authorSubscriptions.get(this.publicKey);
+    if (subInfo && subInfo.initPromise) {
+      await subInfo.initPromise;
+    }
   }
   /**
    * Initialize persistent storage
@@ -542,13 +674,61 @@ class NostrClient {
   }
   /**
    * Publish event to relays
+   * Supports debouncing for replaceable events (kind 30000-39999) to avoid rapid updates
    * @param {Object} event - Unsigned event object
    * @param {Object} options - Publish options
    * @param {boolean} options.waitForRelays - Wait for relay confirmation (default: false for speed)
+   * @param {boolean} options.debounce - Debounce rapid writes to same d-tag (default: true for replaceable events)
    * @returns {Promise<Object>} Signed event with relay publish results
    */
   async publish(event, options = {}) {
     await this._initReady;
+    const waitForRelays = options.waitForRelays || false;
+    const isReplaceable = event.kind >= 3e4 && event.kind < 4e4;
+    const shouldDebounce = isReplaceable && options.debounce !== false && !waitForRelays;
+    if (shouldDebounce) {
+      const dTag = event.tags?.find((t) => t[0] === "d");
+      if (dTag && dTag[1]) {
+        return this._debouncedPublish(event, dTag[1], options);
+      }
+    }
+    return this._doPublish(event, options);
+  }
+  /**
+   * Debounced publish - coalesces rapid writes to the same d-tag
+   * @private
+   */
+  _debouncedPublish(event, dTagPath, options) {
+    return new Promise((resolve, reject) => {
+      const existing = pendingWrites.get(dTagPath);
+      if (existing) {
+        clearTimeout(existing.timer);
+        existing.resolve({
+          event: null,
+          results: [],
+          debounced: true,
+          supersededBy: event
+        });
+      }
+      const timer = setTimeout(async () => {
+        pendingWrites.delete(dTagPath);
+        try {
+          const result = await this._doPublish(event, options);
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        }
+      }, WRITE_DEBOUNCE_MS);
+      pendingWrites.set(dTagPath, { event, timer, resolve, reject });
+      const signedEvent = finalizeEvent(event, this.privateKey);
+      this._cacheEvent(signedEvent);
+    });
+  }
+  /**
+   * Internal publish implementation
+   * @private
+   */
+  async _doPublish(event, options = {}) {
     const waitForRelays = options.waitForRelays || false;
     const signedEvent = finalizeEvent(event, this.privateKey);
     await this._cacheEvent(signedEvent);
@@ -613,20 +793,39 @@ class NostrClient {
   }
   /**
    * Query events from relays
+   * Uses long-lived subscription for cache updates - avoids polling
    * @param {Object} filter - Nostr filter object
    * @param {Object} options - Query options
    * @param {number} options.timeout - Query timeout in ms (default: 30000, set to 0 for no timeout)
    * @param {boolean} options.localFirst - Return local cache immediately, refresh in background (default: true)
+   * @param {boolean} options.forceRelay - Force relay query even if subscription cache is available (default: false)
    * @returns {Promise<Array>} Array of events
    */
   async query(filter, options = {}) {
     await this._initReady;
     const timeout = options.timeout !== void 0 ? options.timeout : 3e4;
     const localFirst = options.localFirst !== false;
+    const forceRelay = options.forceRelay === true;
     if (this.relays.length === 0) {
       const matchingEvents = this._getMatchingCachedEvents(filter);
       return matchingEvents;
     }
+    const subInfo = authorSubscriptions.get(this.publicKey);
+    const isOwnDataQuery = filter.authors && filter.authors.length === 1 && filter.authors[0] === this.publicKey;
+    if (!forceRelay && isOwnDataQuery && subInfo && subInfo.initialized) {
+      const matchingEvents = this._getMatchingCachedEvents(filter);
+      return matchingEvents;
+    }
+    if (isOwnDataQuery && subInfo && !subInfo.initialized) {
+      await Promise.race([
+        subInfo.initPromise,
+        new Promise((resolve) => setTimeout(resolve, Math.min(timeout, AUTHOR_SUB_INIT_TIMEOUT)))
+      ]);
+      if (subInfo.initialized) {
+        const matchingEvents = this._getMatchingCachedEvents(filter);
+        return matchingEvents;
+      }
+    }
     if (filter["#d"] && filter["#d"].length === 1 && filter.kinds && filter.kinds.length === 1) {
       const dTagKey = `d:${filter.kinds[0]}:${filter["#d"][0]}`;
       const dTagCached = this._eventCache.get(dTagKey);
@@ -647,22 +846,78 @@ class NostrClient {
   }
   /**
    * Query relays and update cache
+   * Uses global pending queries map to deduplicate identical concurrent queries
    * @private
    */
   async _queryRelaysAndCache(filter, cacheKey, timeout) {
-    let events = await this.pool.querySync(this.relays, filter, { timeout });
-    if (filter.authors && filter.authors.length > 0) {
-      events = events.filter((event) => filter.authors.includes(event.pubkey));
+    const pending = pendingQueries$1.get(cacheKey);
+    if (pending && Date.now() - pending.timestamp < PENDING_QUERY_TIMEOUT) {
+      return pending.promise;
     }
-    this._eventCache.set(cacheKey, {
-      events,
+    const queryPromise = (async () => {
+      try {
+        let events = await this.pool.querySync(this.relays, filter, { timeout });
+        if (filter.authors && filter.authors.length > 0) {
+          events = events.filter((event) => filter.authors.includes(event.pubkey));
+        }
+        this._eventCache.set(cacheKey, {
+          events,
+          timestamp: Date.now()
+        });
+        this._indexCacheEntry(cacheKey, filter);
+        return events;
+      } finally {
+        pendingQueries$1.delete(cacheKey);
+      }
+    })();
+    pendingQueries$1.set(cacheKey, {
+      promise: queryPromise,
       timestamp: Date.now()
     });
-    if (this._eventCache.size > 100) {
-      const firstKey = this._eventCache.keys().next().value;
-      this._eventCache.delete(firstKey);
+    return queryPromise;
+  }
+  /**
+   * Limit cache size (called after cache operations)
+   * Note: LRU cache handles this automatically, kept for API compatibility
+   * @private
+   */
+  _limitCacheSize() {
+  }
+  /**
+   * Add cache entry to reverse index for fast invalidation
+   * @private
+   */
+  _indexCacheEntry(cacheKey, filter) {
+    if (filter.kinds) {
+      for (const kind2 of filter.kinds) {
+        if (!this._cacheIndex.has(kind2)) {
+          this._cacheIndex.set(kind2, /* @__PURE__ */ new Set());
+        }
+        this._cacheIndex.get(kind2).add(cacheKey);
+      }
+    }
+  }
+  /**
+   * Remove cache entry from reverse index
+   * @private
+   */
+  _unindexCacheEntry(cacheKey) {
+    if (!cacheKey.startsWith("{")) return;
+    try {
+      const filter = JSON.parse(cacheKey);
+      if (filter.kinds) {
+        for (const kind2 of filter.kinds) {
+          const indexSet = this._cacheIndex.get(kind2);
+          if (indexSet) {
+            indexSet.delete(cacheKey);
+            if (indexSet.size === 0) {
+              this._cacheIndex.delete(kind2);
+            }
+          }
+        }
+      }
+    } catch {
     }
-    return events;
   }
   /**
    * Refresh cache in background (fire and forget)
@@ -687,18 +942,33 @@ class NostrClient {
   }
   /**
    * Internal method to refresh a path from relays
+   * Throttled to avoid flooding the relay with repeated requests
    * @private
    */
   async _doBackgroundPathRefresh(path, kind2, options) {
     if (this.relays.length === 0) return;
+    const lastRefresh = backgroundRefreshThrottle.get(path);
+    if (lastRefresh && Date.now() - lastRefresh < BACKGROUND_REFRESH_INTERVAL) {
+      return;
+    }
+    backgroundRefreshThrottle.set(path, Date.now());
+    if (backgroundRefreshThrottle.size > 1e3) {
+      const cutoff = Date.now() - BACKGROUND_REFRESH_INTERVAL;
+      for (const [key, timestamp] of backgroundRefreshThrottle) {
+        if (timestamp < cutoff) {
+          backgroundRefreshThrottle.delete(key);
+        }
+      }
+    }
     const filter = {
       kinds: [kind2],
       authors: options.authors || [this.publicKey],
       "#d": [path],
       limit: 1
     };
+    const cacheKey = JSON.stringify(filter);
     const timeout = options.timeout || 3e4;
-    const events = await this.pool.querySync(this.relays, filter, { timeout });
+    const events = await this._queryRelaysAndCache(filter, cacheKey, timeout);
     const authorFiltered = events.filter(
       (e) => (options.authors || [this.publicKey]).includes(e.pubkey)
     );
@@ -720,17 +990,25 @@ class NostrClient {
   }
   /**
    * Internal method to refresh a prefix from relays
+   * Throttled to avoid flooding the relay with repeated requests
    * @private
    */
   async _doBackgroundPrefixRefresh(prefix, kind2, options) {
     if (this.relays.length === 0) return;
+    const throttleKey = `prefix:${prefix}`;
+    const lastRefresh = backgroundRefreshThrottle.get(throttleKey);
+    if (lastRefresh && Date.now() - lastRefresh < BACKGROUND_REFRESH_INTERVAL) {
+      return;
+    }
+    backgroundRefreshThrottle.set(throttleKey, Date.now());
     const filter = {
       kinds: [kind2],
       authors: options.authors || [this.publicKey],
       limit: options.limit || 1e3
     };
+    const cacheKey = JSON.stringify(filter);
     const timeout = options.timeout || 3e4;
-    let events = await this.pool.querySync(this.relays, filter, { timeout });
+    let events = await this._queryRelaysAndCache(filter, cacheKey, timeout);
     events = events.filter(
       (e) => (options.authors || [this.publicKey]).includes(e.pubkey)
     );
@@ -805,6 +1083,7 @@ class NostrClient {
   }
   /**
    * Subscribe to events
+   * Uses subscription deduplication to avoid creating multiple identical subscriptions
    * @param {Object} filter - Nostr filter object
    * @param {Function} onEvent - Callback for each event
    * @param {Object} options - Subscription options
@@ -812,7 +1091,8 @@ class NostrClient {
    */
   async subscribe(filter, onEvent, options = {}) {
     await this._initReady;
-    const subId = `sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const subId = `sub-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    const filterKey = JSON.stringify(filter);
     if (this.relays.length === 0) {
       const matchingEvents = this._getMatchingCachedEvents(filter);
       const mockSub = {
@@ -837,6 +1117,32 @@ class NostrClient {
         }
       };
     }
+    const existing = activeSubscriptions.get(filterKey);
+    if (existing) {
+      existing.callbacks.add(onEvent);
+      existing.refCount++;
+      return {
+        id: subId,
+        unsubscribe: () => {
+          existing.callbacks.delete(onEvent);
+          existing.refCount--;
+          if (existing.refCount === 0) {
+            if (existing.subscription && existing.subscription.close) {
+              existing.subscription.close();
+            }
+            activeSubscriptions.delete(filterKey);
+          }
+          this._subscriptions.delete(subId);
+        }
+      };
+    }
+    const callbacks = /* @__PURE__ */ new Set([onEvent]);
+    const subscriptionInfo = {
+      callbacks,
+      refCount: 1,
+      subscription: null
+    };
+    activeSubscriptions.set(filterKey, subscriptionInfo);
     const sub = this.pool.subscribeMany(
       this.relays,
       [filter],
@@ -848,18 +1154,33 @@ class NostrClient {
             }
           }
           this._cacheEvent(event);
-          onEvent(event);
+          const subInfo = activeSubscriptions.get(filterKey);
+          if (subInfo) {
+            for (const cb of subInfo.callbacks) {
+              try {
+                cb(event);
+              } catch (err) {
+                console.warn("[nostr] Subscription callback error:", err.message);
+              }
+            }
+          }
         },
         oneose: () => {
           if (options.onEOSE) options.onEOSE();
         }
       }
     );
+    subscriptionInfo.subscription = sub;
     this._subscriptions.set(subId, sub);
     return {
       id: subId,
       unsubscribe: () => {
-        if (sub.close) sub.close();
+        callbacks.delete(onEvent);
+        subscriptionInfo.refCount--;
+        if (subscriptionInfo.refCount === 0) {
+          if (sub.close) sub.close();
+          activeSubscriptions.delete(filterKey);
+        }
         this._subscriptions.delete(subId);
       }
     };
@@ -895,42 +1216,52 @@ class NostrClient {
   }
   /**
    * Invalidate query caches that might be affected by a new event
+   * Uses reverse index for O(1) lookup instead of O(n) scan
    * @private
    */
   _invalidateQueryCachesForEvent(event) {
+    const indexedKeys = this._cacheIndex.get(event.kind);
+    if (!indexedKeys || indexedKeys.size === 0) {
+      return;
+    }
     const keysToDelete = [];
-    for (const [cacheKey, cached] of this._eventCache.entries()) {
-      if (!cacheKey.startsWith("{")) continue;
+    for (const cacheKey of indexedKeys) {
+      const cached = this._eventCache.get(cacheKey);
+      if (!cached) {
+        indexedKeys.delete(cacheKey);
+        continue;
+      }
       try {
         const filter = JSON.parse(cacheKey);
         if (this._eventMatchesFilter(event, filter)) {
           keysToDelete.push(cacheKey);
         }
       } catch {
+        indexedKeys.delete(cacheKey);
       }
     }
     for (const key of keysToDelete) {
       this._eventCache.delete(key);
+      this._unindexCacheEntry(key);
     }
   }
   /**
-   * Cache event in memory and persist
+   * Cache event in memory and persist (batched)
    * @private
    */
   async _cacheEvent(event) {
     this._cacheEventSync(event);
     if (this.persistentStorage) {
-      try {
-        let storageKey = event.id;
-        if (event.kind >= 3e4 && event.kind < 4e4) {
-          const dTag = event.tags.find((t) => t[0] === "d");
-          if (dTag && dTag[1]) {
-            storageKey = dTag[1];
-          }
+      let storageKey = event.id;
+      if (event.kind >= 3e4 && event.kind < 4e4) {
+        const dTag = event.tags.find((t) => t[0] === "d");
+        if (dTag && dTag[1]) {
+          storageKey = dTag[1];
         }
-        await this.persistentStorage.put(storageKey, event);
-      } catch (error) {
-        console.warn("Failed to persist event:", error);
+      }
+      this._persistQueue.set(storageKey, event);
+      if (!this._persistTimer) {
+        this._persistTimer = setTimeout(() => this._flushPersistQueue(), this._persistBatchMs);
       }
     }
     if (this.relays.length === 0) {
@@ -945,6 +1276,26 @@ class NostrClient {
       }
     }
   }
+  /**
+   * Flush batched persistent writes
+   * @private
+   */
+  async _flushPersistQueue() {
+    this._persistTimer = null;
+    if (!this.persistentStorage || this._persistQueue.size === 0) {
+      return;
+    }
+    const toWrite = Array.from(this._persistQueue.entries());
+    this._persistQueue.clear();
+    const writePromises = toWrite.map(async ([key, event]) => {
+      try {
+        await this.persistentStorage.put(key, event);
+      } catch (error) {
+        console.warn(`Failed to persist event ${key}:`, error.message);
+      }
+    });
+    await Promise.all(writePromises);
+  }
   /**
    * Get cached events matching a filter
    * @private
@@ -1032,11 +1383,25 @@ class NostrClient {
   }
   /**
    * Close all connections and subscriptions
+   * @param {Object} options - Close options
+   * @param {boolean} options.flush - Flush pending writes before closing (default: true)
    */
-  close() {
+  async close(options = {}) {
+    const shouldFlush = options.flush !== false;
+    if (shouldFlush && this._persistTimer) {
+      clearTimeout(this._persistTimer);
+      await this._flushPersistQueue();
+    }
     if (this.syncService) {
       this.syncService.stop();
     }
+    const authorSub = authorSubscriptions.get(this.publicKey);
+    if (authorSub && authorSub.subscription) {
+      if (authorSub.subscription.close) {
+        authorSub.subscription.close();
+      }
+      authorSubscriptions.delete(this.publicKey);
+    }
     for (const sub of this._subscriptions.values()) {
       if (sub.close) {
         sub.close();
@@ -1047,6 +1412,7 @@ class NostrClient {
     this._subscriptions.clear();
     this.pool.close(this.relays);
     this._eventCache.clear();
+    this._cacheIndex.clear();
   }
   /**
    * Get relay status
@@ -3196,11 +3562,11 @@ class GunDBBackend extends StorageBackend {
   }
 }
 const name = "holosphere";
-const version$1 = "2.0.0-alpha4";
+const version$1 = "2.0.0-alpha5";
 const description = "Holonic geospatial communication infrastructure combining H3 hexagonal indexing with distributed P2P storage";
 const type = "module";
 const bin = {
-  "holosphere-activitypub": "./bin/holosphere-activitypub.js"
+  "holosphere-activitypub": "bin/holosphere-activitypub.js"
 };
 const main = "./dist/cjs/holosphere.cjs";
 const module = "./dist/esm/holosphere.js";
@@ -3941,6 +4307,9 @@ const h3Operations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   toHolon
 }, Symbol.toStringTag, { value: "Module" }));
 const globalSubscriptions = /* @__PURE__ */ new Map();
+const singlePathSubscriptions = /* @__PURE__ */ new Map();
+const pendingQueries = /* @__PURE__ */ new Map();
+const QUERY_DEDUP_WINDOW = 2e3;
 async function nostrPut(client, path, data, kind2 = 3e4) {
   const dataEvent = {
     kind: kind2,
@@ -3977,6 +4346,27 @@ async function nostrGet(client, path, kind2 = 3e4, options = {}) {
       }
     }
   }
+  const queryKey = `get:${client.publicKey}:${kind2}:${path}:${authors.join(",")}`;
+  const pending = pendingQueries.get(queryKey);
+  if (pending && Date.now() - pending.timestamp < QUERY_DEDUP_WINDOW) {
+    return pending.promise;
+  }
+  const queryPromise = _executeNostrGet(client, path, kind2, authors, timeout, options);
+  pendingQueries.set(queryKey, {
+    promise: queryPromise,
+    timestamp: Date.now()
+  });
+  queryPromise.finally(() => {
+    setTimeout(() => {
+      const current = pendingQueries.get(queryKey);
+      if (current && current.promise === queryPromise) {
+        pendingQueries.delete(queryKey);
+      }
+    }, QUERY_DEDUP_WINDOW);
+  });
+  return queryPromise;
+}
+async function _executeNostrGet(client, path, kind2, authors, timeout, options) {
   const filter = {
     kinds: [kind2],
     authors,
@@ -4010,24 +4400,24 @@ async function nostrGetAll(client, pathPrefix, kind2 = 3e4, options = {}) {
   if (!options.skipPersistent && client.persistentGetAll) {
     const persistedEvents = await client.persistentGetAll(pathPrefix);
     if (persistedEvents.length > 0) {
-      const byPath2 = /* @__PURE__ */ new Map();
+      const byPath = /* @__PURE__ */ new Map();
       for (const event of persistedEvents) {
         if (!event || !event.tags) continue;
         const dTag = event.tags.find((t) => t[0] === "d");
         if (!dTag || !dTag[1] || !dTag[1].startsWith(pathPrefix)) continue;
         const path = dTag[1];
-        const existing = byPath2.get(path);
+        const existing = byPath.get(path);
         if (!existing || event.created_at > existing.created_at) {
           try {
             const data = JSON.parse(event.content);
             if (data._deleted) {
-              byPath2.delete(path);
+              byPath.delete(path);
               continue;
             }
             if (options.includeAuthor) {
               data._author = event.pubkey;
             }
-            byPath2.set(path, { data, created_at: event.created_at });
+            byPath.set(path, { data, created_at: event.created_at });
           } catch (error) {
           }
         }
@@ -4035,9 +4425,30 @@ async function nostrGetAll(client, pathPrefix, kind2 = 3e4, options = {}) {
       if (client.refreshPrefixInBackground) {
         client.refreshPrefixInBackground(pathPrefix, kind2, { authors, timeout, limit: limit2 });
       }
-      return Array.from(byPath2.values()).map((item) => item.data);
+      return Array.from(byPath.values()).map((item) => item.data);
     }
   }
+  const queryKey = `getAll:${client.publicKey}:${kind2}:${pathPrefix}:${authors.join(",")}`;
+  const pending = pendingQueries.get(queryKey);
+  if (pending && Date.now() - pending.timestamp < QUERY_DEDUP_WINDOW) {
+    return pending.promise;
+  }
+  const queryPromise = _executeNostrGetAll(client, pathPrefix, kind2, authors, timeout, limit2, options);
+  pendingQueries.set(queryKey, {
+    promise: queryPromise,
+    timestamp: Date.now()
+  });
+  queryPromise.finally(() => {
+    setTimeout(() => {
+      const current = pendingQueries.get(queryKey);
+      if (current && current.promise === queryPromise) {
+        pendingQueries.delete(queryKey);
+      }
+    }, QUERY_DEDUP_WINDOW);
+  });
+  return queryPromise;
+}
+async function _executeNostrGetAll(client, pathPrefix, kind2, authors, timeout, limit2, options) {
   const filter = {
     kinds: [kind2],
     authors,
@@ -4226,7 +4637,29 @@ async function nostrDeleteAll(client, pathPrefix, kind2 = 3e4) {
 }
 function nostrSubscribe(client, path, callback, options = {}) {
   const kind2 = options.kind || 3e4;
-  options.includeInitial !== false;
+  const subscriptionKey = `single:${client.publicKey}:${kind2}:${path}`;
+  const existing = singlePathSubscriptions.get(subscriptionKey);
+  if (existing) {
+    existing.callbacks.push(callback);
+    return {
+      unsubscribe: () => {
+        const idx = existing.callbacks.indexOf(callback);
+        if (idx > -1) {
+          existing.callbacks.splice(idx, 1);
+        }
+        if (existing.callbacks.length === 0) {
+          existing.subscription.unsubscribe();
+          singlePathSubscriptions.delete(subscriptionKey);
+        }
+      }
+    };
+  }
+  const callbacks = [callback];
+  const subscriptionInfo = {
+    callbacks,
+    subscription: null
+  };
+  singlePathSubscriptions.set(subscriptionKey, subscriptionInfo);
   const filter = {
     kinds: [kind2],
     authors: [client.publicKey],
@@ -4239,11 +4672,6 @@ function nostrSubscribe(client, path, callback, options = {}) {
     filter,
     (event) => {
       if (event.pubkey !== client.publicKey) {
-        console.warn("[nostrSubscribe] Rejecting event from different author:", {
-          expected: client.publicKey,
-          received: event.pubkey,
-          eventId: event.id
-        });
         return;
       }
       try {
@@ -4251,7 +4679,13 @@ function nostrSubscribe(client, path, callback, options = {}) {
         if (data._deleted) {
           return;
         }
-        callback(data, event);
+        for (const cb of callbacks) {
+          try {
+            cb(data, event);
+          } catch (err) {
+            console.error("Subscription callback error:", err);
+          }
+        }
       } catch (error) {
         console.error("Failed to parse event in subscription:", error);
       }
@@ -4261,7 +4695,19 @@ function nostrSubscribe(client, path, callback, options = {}) {
       }
     }
   );
-  return subscription;
+  subscriptionInfo.subscription = subscription;
+  return {
+    unsubscribe: () => {
+      const idx = callbacks.indexOf(callback);
+      if (idx > -1) {
+        callbacks.splice(idx, 1);
+      }
+      if (callbacks.length === 0) {
+        subscription.unsubscribe();
+        singlePathSubscriptions.delete(subscriptionKey);
+      }
+    }
+  };
 }
 async function nostrSubscribeMany(client, pathPrefix, callback, options = {}) {
   const kind2 = options.kind || 3e4;
@@ -5013,7 +5459,7 @@ const sha256 = sha256$1;
 let secp256k1 = null;
 async function loadCrypto() {
   if (!secp256k1) {
-    const module2 = await import("./secp256k1-DN4FVXcv.js");
+    const module2 = await import("./secp256k1-69sS9O-P.js");
     secp256k1 = module2.secp256k1;
   }
   return secp256k1;
@@ -16643,7 +17089,7 @@ class ChainManager {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      const ethersModule = await import("./index-Cz-PLCUR.js");
+      const ethersModule = await import("./index-Cp3xctq8.js");
       this.ethers = ethersModule;
     }
     return this.ethers;
@@ -25407,7 +25853,7 @@ class ContractDeployer {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      this.ethers = await import("./index-Cz-PLCUR.js");
+      this.ethers = await import("./index-Cp3xctq8.js");
     }
     return this.ethers;
   }
@@ -25745,7 +26191,7 @@ class ContractOperations {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      this.ethers = await import("./index-Cz-PLCUR.js");
+      this.ethers = await import("./index-Cp3xctq8.js");
     }
     return this.ethers;
   }
@@ -37420,4 +37866,4 @@ export {
   exists as y,
   bytes as z
 };
-//# sourceMappingURL=index-CV0eOogK.js.map
+//# sourceMappingURL=index-Bbey4GkP.js.map