holosphere 2.0.0-alpha7 → 2.0.0-alpha8

package/dist/{index-d6f4RJBM.js → index-4XHHKe6S.js}

@@ -1,4 +1,4 @@
-import { getPublicKey as getPublicKey$2, finalizeEvent, SimplePool, nip19, nip04, verifyEvent as verifyEvent$1 } from "nostr-tools";
+import { getPublicKey as getPublicKey$2, finalizeEvent, SimplePool, nip19, nip04, nip44, 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,12 +361,12 @@ 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-D8kOl0oK.js");
+    const { IndexedDBStorage } = await import("./indexeddb-storage-lExjjFlV.js");
     const storage = new IndexedDBStorage();
     await storage.init(namespace);
     return storage;
   } else {
-    const { MemoryStorage } = await import("./memory-storage-DBQK622V.js");
+    const { MemoryStorage } = await import("./memory-storage-C68adso2.js");
     const storage = new MemoryStorage();
     await storage.init(namespace);
     return storage;
@@ -1628,8 +1628,16 @@ function buildGlobalPath(appname, tableName, key = null) {
 function encodePathComponent$1(component) {
   return encodeURIComponent(component).replace(/%2F/g, "/");
 }
+function getGunPath(gun, path) {
+  const parts = path.split("/").filter((p) => p.length > 0);
+  let ref = gun;
+  for (const part of parts) {
+    ref = ref.get(part);
+  }
+  return ref;
+}
 function serializeForGun(data) {
-  return { _json: JSON.stringify(data) };
+  return JSON.stringify(data);
 }
 function deserializeFromGun(data) {
   if (!data) {
@@ -1681,15 +1689,29 @@ function deserializeFromGun(data) {
 async function write$2(gun, path, data) {
   try {
     const serialized = serializeForGun(data);
-    await gunPut(gun.get(path), serialized, 2e3);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    return true;
+    const parts = path.split("/").filter((p) => p.length > 0);
+    console.log("[gun-wrapper] write:", { path, parts, dataId: data?.id });
+    const ref = getGunPath(gun, path);
+    console.log("[gun-wrapper] write ref soul:", ref?._.get);
+    const ack = await gunPut(ref, serialized, 5e3);
+    console.log("[gun-wrapper] write ack:", { ok: ack.ok, timeout: ack.timeout });
+    if (ack.timeout) {
+      console.warn("[gun-wrapper] write timed out (data may not be persisted):", path);
+    }
+    console.log("[gun-wrapper] write complete:", path);
+    return { ok: true, timeout: ack.timeout || false };
   } catch (error) {
+    console.error("[gun-wrapper] write error:", error);
     throw error;
   }
 }
 async function read$2(gun, path) {
-  const rawData = await gunPromise(gun.get(path), 2e3);
+  const parts = path.split("/").filter((p) => p.length > 0);
+  console.log("[gun-wrapper] read:", { path, parts });
+  const ref = getGunPath(gun, path);
+  console.log("[gun-wrapper] read ref soul:", ref?._.get);
+  const rawData = await gunPromise(ref, 2e3);
+  console.log("[gun-wrapper] read rawData:", rawData ? typeof rawData === "string" ? rawData.substring(0, 100) : "object" : "null");
   if (!rawData) {
     return null;
   }
@@ -1700,16 +1722,20 @@ async function read$2(gun, path) {
   return data;
 }
 async function readAll$2(gun, path, timeout = 5e3) {
+  const parts = path.split("/").filter((p) => p.length > 0);
+  console.log("[gun-wrapper] readAll:", { path, parts });
   return new Promise((resolve) => {
     const output2 = /* @__PURE__ */ new Map();
     let settled = false;
     let expectedCount = 0;
     let receivedCount = 0;
-    const ref = gun.get(path);
+    const ref = getGunPath(gun, path);
+    console.log("[gun-wrapper] readAll ref soul:", ref?._.get);
     const tryResolve = () => {
       if (settled) return;
       if (expectedCount > 0 && receivedCount >= expectedCount) {
         settled = true;
+        console.log("[gun-wrapper] readAll resolved with", output2.size, "items");
         resolve(Array.from(output2.values()));
       }
     };
@@ -1718,14 +1744,20 @@ async function readAll$2(gun, path, timeout = 5e3) {
     };
     ref.once((parentData) => {
       if (settled) return;
+      console.log("[gun-wrapper] readAll parentData:", parentData);
+      console.log("[gun-wrapper] readAll parentData keys:", parentData ? Object.keys(parentData).filter((k) => k !== "_") : "null");
+      console.log("[gun-wrapper] readAll parentData type:", typeof parentData);
       if (!parentData) {
         settled = true;
+        console.log("[gun-wrapper] readAll: no parent data, returning empty");
         resolve([]);
         return;
       }
       const keys = Object.keys(parentData).filter((k) => k !== "_");
+      console.log("[gun-wrapper] readAll keys:", keys);
       if (keys.length === 0) {
         settled = true;
+        console.log("[gun-wrapper] readAll: no keys, returning empty");
         resolve([]);
         return;
       }
@@ -1767,7 +1799,7 @@ async function readAll$2(gun, path, timeout = 5e3) {
   });
 }
 async function update$2(gun, path, updates) {
-  const rawData = await gunPromise(gun.get(path));
+  const rawData = await gunPromise(getGunPath(gun, path));
   if (!rawData) {
     return false;
   }
@@ -1778,7 +1810,8 @@ async function update$2(gun, path, updates) {
   const merged = { ...existing, ...updates };
   try {
     const serialized = serializeForGun(merged);
-    await gunPut(gun.get(path), serialized);
+    await gunPut(getGunPath(gun, path), serialized, 2e3);
+    await new Promise((resolve) => setTimeout(resolve, 200));
     return true;
   } catch (error) {
     throw error;
@@ -1786,7 +1819,7 @@ async function update$2(gun, path, updates) {
 }
 async function deleteData$2(gun, path) {
   try {
-    const rawData = await gunPromise(gun.get(path));
+    const rawData = await gunPromise(getGunPath(gun, path));
     if (!rawData) {
       return true;
     }
@@ -1796,7 +1829,8 @@ async function deleteData$2(gun, path) {
       _deleted: true,
       _deletedAt: Date.now()
     };
-    await gunPut(gun.get(path), serializeForGun(tombstone));
+    await gunPut(getGunPath(gun, path), serializeForGun(tombstone), 2e3);
+    await new Promise((resolve) => setTimeout(resolve, 200));
     return true;
   } catch (error) {
     throw error;
@@ -1818,7 +1852,7 @@ function subscribe$2(gun, path, callback, options = {}) {
   const pathParts = path.split("/");
   const isPrefix = options.prefix !== void 0 ? options.prefix : pathParts.length <= 3;
   if (isPrefix) {
-    const ref = gun.get(path);
+    const ref = getGunPath(gun, path);
     ref.map().on((data, key) => {
       if (data && !key.startsWith("_")) {
         const deserialized = deserializeFromGun(data);
@@ -1836,7 +1870,7 @@ function subscribe$2(gun, path, callback, options = {}) {
       }
     };
   } else {
-    const listener = gun.get(path).on((data, key) => {
+    const listener = getGunPath(gun, path).on((data, key) => {
       if (data) {
         const deserialized = deserializeFromGun(data);
         if (deserialized && !deserialized._deleted) {
@@ -3193,24 +3227,44 @@ class GunDBBackend extends StorageBackend {
     this.schemaValidator = null;
     this.subscriptions = /* @__PURE__ */ new Map();
     this.subscriptionCounter = 0;
+    this.writeCache = /* @__PURE__ */ new Map();
+    this.writeCacheTTL = 3e5;
+    this.pendingWrites = /* @__PURE__ */ new Map();
+    this.maxWriteRetries = 5;
+    this.writeRetryInterval = 1e4;
   }
   async init() {
     let Gun;
     try {
+      console.log("[gundb-backend] Importing Gun...");
       const gunModule = await import("./browser-BSniCNqO.js").then((n2) => n2.b);
       Gun = gunModule.default || gunModule;
+      console.log("[gundb-backend] Gun imported:", typeof Gun);
     } catch (error) {
       throw new Error(
         'GunDB backend requires the "gun" package. Install it with: npm install gun'
       );
     }
+    const dataDir = this.config.dataDir || "radata";
     const gunConfig = {
       peers: this.config.peers || [],
       radisk: this.config.radisk !== false,
       localStorage: this.config.localStorage !== false,
-      file: this.config.dataDir
+      file: dataDir
     };
+    console.log("[gundb-backend] Gun config:", JSON.stringify(gunConfig));
     this.gun = Gun(gunConfig);
+    console.log("[gundb-backend] Gun instance created:", !!this.gun);
+    try {
+      const testKey = `_test_${Date.now()}`;
+      this.gun.get(testKey).put({ test: true }, (ack) => {
+        console.log("[gundb-backend] Gun test write ack:", ack);
+      });
+      console.log("[gundb-backend] Gun test write initiated");
+    } catch (e) {
+      console.error("[gundb-backend] Gun test write failed:", e.message);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
     try {
       const SEA = Gun.SEA;
       if (SEA) {
@@ -3236,6 +3290,88 @@ class GunDBBackend extends StorageBackend {
     await this.schemaValidator.init();
   }
   // ============================================================================
+  // WRITE CACHE (for immediate consistency)
+  // ============================================================================
+  /**
+   * Add item to the local write cache for immediate consistency
+   * @private
+   */
+  _addToWriteCache(path, data) {
+    if (!data || !data.id) return;
+    const parentPath = path.substring(0, path.lastIndexOf("/"));
+    if (!parentPath) return;
+    if (!this.writeCache.has(parentPath)) {
+      this.writeCache.set(parentPath, /* @__PURE__ */ new Map());
+    }
+    const pathCache = this.writeCache.get(parentPath);
+    pathCache.set(data.id.toString(), {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Remove item from write cache (e.g., on delete)
+   * @private
+   */
+  _removeFromWriteCache(path, id2) {
+    const parentPath = path.substring(0, path.lastIndexOf("/"));
+    const pathCache = this.writeCache.get(parentPath);
+    if (pathCache) {
+      pathCache.delete(id2.toString());
+    }
+  }
+  /**
+   * Get cached writes for a path, filtering out expired entries
+   * @private
+   */
+  _getWriteCacheEntries(path) {
+    const pathCache = this.writeCache.get(path);
+    if (!pathCache) return [];
+    const now = Date.now();
+    const validEntries = [];
+    for (const [id2, entry] of pathCache) {
+      if (now - entry.timestamp < this.writeCacheTTL) {
+        validEntries.push(entry.data);
+      } else {
+        pathCache.delete(id2);
+      }
+    }
+    return validEntries;
+  }
+  /**
+   * Merge cached writes with results from Gun
+   * @private
+   */
+  _mergeWithWriteCache(path, gunResults) {
+    const cachedWrites = this._getWriteCacheEntries(path);
+    if (cachedWrites.length === 0) return gunResults;
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const item of gunResults) {
+      if (item && item.id) {
+        resultMap.set(item.id.toString(), item);
+      }
+    }
+    for (const item of cachedWrites) {
+      if (item && item.id && !item._deleted) {
+        resultMap.set(item.id.toString(), item);
+      } else if (item && item.id && item._deleted) {
+        resultMap.delete(item.id.toString());
+      }
+    }
+    return Array.from(resultMap.values());
+  }
+  /**
+   * Clear write cache for a specific path or all paths
+   * @param {string} [path] - Optional path to clear, clears all if not provided
+   */
+  clearWriteCache(path = null) {
+    if (path) {
+      this.writeCache.delete(path);
+    } else {
+      this.writeCache.clear();
+    }
+  }
+  // ============================================================================
   // PATH BUILDING
   // ============================================================================
   buildPath(appName, holonId, lensName, key = null) {
@@ -3253,19 +3389,56 @@ class GunDBBackend extends StorageBackend {
       if (pathParts.length >= 3) {
         const lens = pathParts[2];
         if (!this.isReference(data)) {
-          const result = await this.schemaValidator.validateData(
+          const result2 = await this.schemaValidator.validateData(
             this.gun,
             this.appName,
             lens,
             data
           );
-          if (!result.valid) {
-            throw new Error(`Schema validation failed: ${JSON.stringify(result.errors)}`);
+          if (!result2.valid) {
+            throw new Error(`Schema validation failed: ${JSON.stringify(result2.errors)}`);
           }
         }
       }
     }
-    return write$2(this.gun, path, data);
+    this._addToWriteCache(path, data);
+    const result = await this._writeWithRetry(path, data);
+    return result;
+  }
+  /**
+   * Write to Gun with automatic retry on timeout
+   * @private
+   */
+  async _writeWithRetry(path, data, attempt = 0) {
+    const result = await write$2(this.gun, path, data);
+    if (result.timeout && attempt < this.maxWriteRetries) {
+      this.pendingWrites.set(path, {
+        data,
+        retries: attempt + 1,
+        lastAttempt: Date.now()
+      });
+      this._scheduleRetry(path);
+    } else if (!result.timeout) {
+      this.pendingWrites.delete(path);
+    }
+    return result;
+  }
+  /**
+   * Schedule a background retry for a pending write
+   * @private
+   */
+  _scheduleRetry(path) {
+    setTimeout(async () => {
+      const pending = this.pendingWrites.get(path);
+      if (!pending) return;
+      if (pending.retries >= this.maxWriteRetries) {
+        console.warn(`[gundb-backend] Max retries reached for: ${path}`);
+        this.pendingWrites.delete(path);
+        return;
+      }
+      console.log(`[gundb-backend] Retrying write (attempt ${pending.retries + 1}): ${path}`);
+      await this._writeWithRetry(path, pending.data, pending.retries);
+    }, this.writeRetryInterval);
   }
   async read(path, options = {}) {
     const data = await read$2(this.gun, path);
@@ -3275,7 +3448,8 @@ class GunDBBackend extends StorageBackend {
     return data;
   }
   async readAll(path, options = {}) {
-    const items = await readAll$2(this.gun, path);
+    const gunItems = await readAll$2(this.gun, path);
+    const items = this._mergeWithWriteCache(path, gunItems);
     if (options.resolveReferences) {
       const resolved = [];
       for (const item of items) {
@@ -3296,7 +3470,20 @@ class GunDBBackend extends StorageBackend {
     return update$2(this.gun, path, updates);
   }
   async delete(path) {
-    return deleteData$2(this.gun, path);
+    const result = await deleteData$2(this.gun, path);
+    const pathParts = path.split("/");
+    const id2 = pathParts[pathParts.length - 1];
+    if (id2) {
+      const parentPath = path.substring(0, path.lastIndexOf("/"));
+      if (!this.writeCache.has(parentPath)) {
+        this.writeCache.set(parentPath, /* @__PURE__ */ new Map());
+      }
+      this.writeCache.get(parentPath).set(id2.toString(), {
+        data: { id: id2, _deleted: true },
+        timestamp: Date.now()
+      });
+    }
+    return result;
   }
   async deleteAll(path) {
     const items = await this.readAll(path);
@@ -3314,16 +3501,67 @@ class GunDBBackend extends StorageBackend {
   // GLOBAL TABLE OPERATIONS
   // ============================================================================
   async writeGlobal(tableName, data) {
-    return writeGlobal$1(this.gun, this.appName, tableName, data);
+    const path = this.buildGlobalPath(tableName, data.id);
+    this._addToWriteCache(path, data);
+    const result = await this._writeGlobalWithRetry(tableName, data);
+    return result;
+  }
+  /**
+   * Write to global table with automatic retry on timeout
+   * @private
+   */
+  async _writeGlobalWithRetry(tableName, data, attempt = 0) {
+    const path = this.buildGlobalPath(tableName, data.id);
+    const result = await writeGlobal$1(this.gun, this.appName, tableName, data);
+    if (result.timeout && attempt < this.maxWriteRetries) {
+      this.pendingWrites.set(path, {
+        data: { tableName, data },
+        isGlobal: true,
+        retries: attempt + 1,
+        lastAttempt: Date.now()
+      });
+      this._scheduleGlobalRetry(path, tableName);
+    } else if (!result.timeout) {
+      this.pendingWrites.delete(path);
+    }
+    return result;
+  }
+  /**
+   * Schedule a background retry for a pending global write
+   * @private
+   */
+  _scheduleGlobalRetry(path, tableName) {
+    setTimeout(async () => {
+      const pending = this.pendingWrites.get(path);
+      if (!pending || !pending.isGlobal) return;
+      if (pending.retries >= this.maxWriteRetries) {
+        console.warn(`[gundb-backend] Max retries reached for global: ${path}`);
+        this.pendingWrites.delete(path);
+        return;
+      }
+      console.log(`[gundb-backend] Retrying global write (attempt ${pending.retries + 1}): ${path}`);
+      await this._writeGlobalWithRetry(tableName, pending.data.data, pending.retries);
+    }, this.writeRetryInterval);
   }
   async readGlobal(tableName, key) {
     return readGlobal$1(this.gun, this.appName, tableName, key);
   }
   async readAllGlobal(tableName, timeout = 5e3) {
-    return readAllGlobal(this.gun, this.appName, tableName, timeout);
+    const gunItems = await readAllGlobal(this.gun, this.appName, tableName, timeout);
+    const path = this.buildGlobalPath(tableName);
+    return this._mergeWithWriteCache(path, gunItems);
   }
   async deleteGlobal(tableName, key) {
-    return deleteGlobal$1(this.gun, this.appName, tableName, key);
+    const result = await deleteGlobal$1(this.gun, this.appName, tableName, key);
+    const path = this.buildGlobalPath(tableName);
+    if (!this.writeCache.has(path)) {
+      this.writeCache.set(path, /* @__PURE__ */ new Map());
+    }
+    this.writeCache.get(path).set(key.toString(), {
+      data: { id: key, _deleted: true },
+      timestamp: Date.now()
+    });
+    return result;
   }
   async deleteAllGlobal(tableName) {
     return deleteAllGlobal$1(this.gun, this.appName, tableName);
@@ -3594,6 +3832,7 @@ class GunDBBackend extends StorageBackend {
     if (this.schemaValidator) {
       this.schemaValidator.clearCache();
     }
+    this.writeCache.clear();
     if (this.auth) {
       this.auth.logout();
     }
@@ -3629,7 +3868,7 @@ class GunDBBackend extends StorageBackend {
   }
 }
 const name = "holosphere";
-const version$1 = "2.0.0-alpha7";
+const version$1 = "2.0.0-alpha8";
 const description = "Holonic geospatial communication infrastructure combining H3 hexagonal indexing with distributed P2P storage";
 const type = "module";
 const bin = {
@@ -3648,6 +3887,8 @@ const exports = {
 const scripts = {
   dev: "vite",
   build: "vite build",
+  "build:cdn": "vite build --config vite.config.cdn.js",
+  "build:all": "npm run build && npm run build:cdn",
   test: "vitest run",
   "test:watch": "vitest",
   "test:coverage": "vitest run --coverage",
@@ -3735,7 +3976,7 @@ let HoloSphere$1 = class HoloSphere {
    * @param {string} config.backend - Storage backend: 'nostr' | 'gundb' | 'activitypub' (default: 'nostr')
    * @param {string[]} config.relays - Nostr relay URLs (default from HOLOSPHERE_RELAYS env or ['wss://relay.holons.io', 'wss://relay.nostr.band'])
    * @param {string} config.privateKey - Private key for signing (hex format, optional)
-   * @param {string} config.logLevel - Log verbosity: ERROR|WARN|INFO|DEBUG (default: 'WARN')
+   * @param {string} config.logLevel - Log verbosity: ERROR|WARN|INFO|DEBUG (default: 'INFO')
    * @param {boolean} config.hybridMode - Enable hybrid mode (local + relay queries) (default: true)
    * @param {Object} config.gundb - GunDB-specific configuration
    * @param {Object} config.activitypub - ActivityPub-specific configuration
@@ -3764,7 +4005,7 @@ let HoloSphere$1 = class HoloSphere {
       backend: config.backend || "nostr",
       relays: config.relays || getDefaultRelays(),
       privateKey: config.privateKey || getEnv("HOLOSPHERE_PRIVATE_KEY"),
-      logLevel: config.logLevel || getEnv("HOLOSPHERE_LOG_LEVEL") || "WARN",
+      logLevel: config.logLevel || getEnv("HOLOSPHERE_LOG_LEVEL") || "INFO",
       hybridMode: config.hybridMode !== false
       // Enable by default
     };
@@ -4396,20 +4637,23 @@ async function nostrGet(client, path, kind2 = 3e4, options = {}) {
   if (!options.skipPersistent && client.persistentGet) {
     const persistedEvent = await client.persistentGet(path);
     if (persistedEvent && persistedEvent.content) {
-      try {
-        const data = JSON.parse(persistedEvent.content);
-        if (data._deleted) {
-          return null;
-        }
-        if (options.includeAuthor) {
-          data._author = persistedEvent.pubkey;
-        }
-        if (client.refreshPathInBackground) {
-          client.refreshPathInBackground(path, kind2, { authors, timeout });
+      if (!authors.includes(persistedEvent.pubkey)) ;
+      else {
+        try {
+          const data = JSON.parse(persistedEvent.content);
+          if (data._deleted) {
+            return null;
+          }
+          if (options.includeAuthor) {
+            data._author = persistedEvent.pubkey;
+          }
+          if (client.refreshPathInBackground) {
+            client.refreshPathInBackground(path, kind2, { authors, timeout });
+          }
+          return data;
+        } catch (error) {
+          console.warn("[nostrGet] Failed to parse persisted event:", error);
         }
-        return data;
-      } catch (error) {
-        console.warn("[nostrGet] Failed to parse persisted event:", error);
       }
     }
   }
@@ -4443,10 +4687,11 @@ async function _executeNostrGet(client, path, kind2, authors, timeout, options)
     // Increase limit to get events from all authors
   };
   const events = await client.query(filter, { timeout });
-  if (events.length === 0) {
+  const authoredEvents = events.filter((event2) => authors.includes(event2.pubkey));
+  if (authoredEvents.length === 0) {
     return null;
   }
-  const event = events.sort((a, b2) => b2.created_at - a.created_at)[0];
+  const event = authoredEvents.sort((a, b2) => b2.created_at - a.created_at)[0];
   try {
     const data = JSON.parse(event.content);
     if (data._deleted) {
@@ -4470,6 +4715,7 @@ async function nostrGetAll(client, pathPrefix, kind2 = 3e4, options = {}) {
       const byPath = /* @__PURE__ */ new Map();
       for (const event of persistedEvents) {
         if (!event || !event.tags) continue;
+        if (!authors.includes(event.pubkey)) continue;
         const dTag = event.tags.find((t) => t[0] === "d");
         if (!dTag || !dTag[1] || !dTag[1].startsWith(pathPrefix)) continue;
         const path = dTag[1];
@@ -4524,7 +4770,9 @@ async function _executeNostrGetAll(client, pathPrefix, kind2, authors, timeout,
   const events = await client.query(filter, { timeout });
   const matching = events.filter((event) => {
     const dTag = event.tags.find((t) => t[0] === "d");
-    return dTag && dTag[1] && dTag[1].startsWith(pathPrefix);
+    const pathMatches = dTag && dTag[1] && dTag[1].startsWith(pathPrefix);
+    const authorAllowed = authors.includes(event.pubkey);
+    return pathMatches && authorAllowed;
   });
   const byPath = /* @__PURE__ */ new Map();
   for (const event of matching) {
@@ -4560,7 +4808,9 @@ async function nostrGetAllHybrid(client, pathPrefix, kind2 = 3e4, options = {})
   const events = await queryMethod.call(client, filter, { timeout });
   const matching = events.filter((event) => {
     const dTag = event.tags.find((t) => t[0] === "d");
-    return dTag && dTag[1] && dTag[1].startsWith(pathPrefix);
+    const pathMatches = dTag && dTag[1] && dTag[1].startsWith(pathPrefix);
+    const authorAllowed = authors.includes(event.pubkey);
+    return pathMatches && authorAllowed;
   });
   const byPath = /* @__PURE__ */ new Map();
   for (const event of matching) {
@@ -4986,30 +5236,45 @@ function buildPath(appName, holonId, lensName, key = null) {
   return buildPath$1(appName, holonId, lensName, key);
 }
 async function write(client, path, data) {
+  if (client.write && client.gun) {
+    return client.write(path, data);
+  }
   if (client.gun) {
     return write$2(client.gun, path, data);
   }
   return write$1(client, path, data);
 }
 async function read(client, path, options = {}) {
+  if (client.read && client.gun) {
+    return client.read(path, options);
+  }
   if (client.gun) {
     return read$2(client.gun, path);
   }
   return read$1(client, path, options);
 }
 async function readAll(client, path, options = {}) {
+  if (client.readAll && client.gun) {
+    return client.readAll(path, options);
+  }
   if (client.gun) {
     return readAll$2(client.gun, path);
   }
   return readAll$1(client, path, options);
 }
 async function update(client, path, updates) {
+  if (client.update && client.gun) {
+    return client.update(path, updates);
+  }
   if (client.gun) {
     return update$2(client.gun, path, updates);
   }
   return update$1(client, path, updates);
 }
 async function deleteData(client, path) {
+  if (client.delete && client.gun) {
+    return client.delete(path);
+  }
   if (client.gun) {
     return deleteData$2(client.gun, path);
   }
@@ -5022,6 +5287,9 @@ async function deleteAll(client, path) {
   return deleteAll$1(client, path);
 }
 function subscribe(client, path, callback, options = {}) {
+  if (client.subscribe && client.gun) {
+    return client.subscribe(path, callback, options);
+  }
   if (client.gun) {
     return subscribe$2(client.gun, path, callback, options);
   }
@@ -5526,7 +5794,7 @@ const sha256 = sha256$1;
 let secp256k1 = null;
 async function loadCrypto() {
   if (!secp256k1) {
-    const module2 = await import("./secp256k1-DYm_CMqW.js");
+    const module2 = await import("./secp256k1-OM8siPyy.js");
     secp256k1 = module2.secp256k1;
   }
   return secp256k1;
@@ -6530,6 +6798,16 @@ async function encryptNIP04(privateKey, recipientPubKey, content) {
 async function decryptNIP04(privateKey, senderPubKey, encryptedContent) {
   return await nip04.decrypt(privateKey, senderPubKey, encryptedContent);
 }
+function encryptNIP44(privateKey, recipientPubKey, content) {
+  const privKeyBytes = hexToBytes(privateKey);
+  const conversationKey = nip44.v2.utils.getConversationKey(privKeyBytes, recipientPubKey);
+  return nip44.v2.encrypt(content, conversationKey);
+}
+function decryptNIP44(privateKey, senderPubKey, encryptedContent) {
+  const privKeyBytes = hexToBytes(privateKey);
+  const conversationKey = nip44.v2.utils.getConversationKey(privKeyBytes, senderPubKey);
+  return nip44.v2.decrypt(encryptedContent, conversationKey);
+}
 function createSignedEvent(kind2, content, tags, privateKey) {
   const event = {
     kind: kind2,
@@ -6583,7 +6861,9 @@ const nostrUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   createDMEvent,
   createSignedEvent,
   decryptNIP04,
+  decryptNIP44,
   encryptNIP04,
+  encryptNIP44,
   generateNonce,
   getPublicKey,
   hexToBytes,
@@ -6645,7 +6925,7 @@ function createFederationResponse({
 async function sendFederationRequest$1(client, privateKey, recipientPubKey, request) {
   try {
     const content = JSON.stringify(request);
-    const encrypted = await encryptNIP04(privateKey, recipientPubKey, content);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
     const event = createDMEvent(recipientPubKey, encrypted, privateKey);
     if (client?.publish) {
       await client.publish(event);
@@ -6663,7 +6943,7 @@ async function sendFederationRequest$1(client, privateKey, recipientPubKey, requ
 async function sendFederationResponse(client, privateKey, recipientPubKey, response) {
   try {
     const content = JSON.stringify(response);
-    const encrypted = await encryptNIP04(privateKey, recipientPubKey, content);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
     const event = createDMEvent(recipientPubKey, encrypted, privateKey);
     if (client?.publish) {
       await client.publish(event);
@@ -6690,7 +6970,12 @@ function subscribeToFederationDMs(client, privateKey, publicKey, handlers) {
     const pTag = event.tags?.find((t) => t[0] === "p");
     if (!pTag || pTag[1] !== publicKey) return;
     try {
-      const decrypted = await decryptNIP04(privateKey, event.pubkey, event.content);
+      let decrypted;
+      try {
+        decrypted = decryptNIP44(privateKey, event.pubkey, event.content);
+      } catch (nip44Error) {
+        decrypted = await decryptNIP04(privateKey, event.pubkey, event.content);
+      }
       const payload = JSON.parse(decrypted);
       if (payload.type === "federation_request" && payload.version === "1.0") {
         console.log("[Handshake] Received federation request from:", event.pubkey.substring(0, 8) + "...");
@@ -7010,7 +7295,7 @@ async function createSubscription(client, path, callback, options = {}) {
     lastInvoke = now;
     callback(resolvedData, key);
   };
-  const subscription = await subscribe(client, path, wrappedCallback, {});
+  const subscription = await subscribe(client, path, wrappedCallback, { realtimeOnly });
   return {
     path,
     unsubscribe: () => {
@@ -17160,7 +17445,7 @@ class ChainManager {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      const ethersModule = await import("./index-jmTHEbR2.js");
+      const ethersModule = await import("./index-BjP1TXGz.js");
       this.ethers = ethersModule;
     }
     return this.ethers;
@@ -25929,7 +26214,7 @@ class ContractDeployer {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      this.ethers = await import("./index-jmTHEbR2.js");
+      this.ethers = await import("./index-BjP1TXGz.js");
     }
     return this.ethers;
   }
@@ -26291,7 +26576,7 @@ class ContractOperations {
    */
   async _loadEthers() {
     if (!this.ethers) {
-      this.ethers = await import("./index-jmTHEbR2.js");
+      this.ethers = await import("./index-BjP1TXGz.js");
     }
     return this.ethers;
   }
@@ -35542,8 +35827,7 @@ const ContractABIs = {
   Zoned: ZonedABI,
   Appreciative: AppreciativeABI,
   Bundle: BundleABI,
-  Holons: HolonsABI,
-  TestToken: TestTokenABI
+  Holons: HolonsABI
 };
 function formatEthNumber(wei) {
   return Number(formatEther(wei));
@@ -37040,6 +37324,7 @@ class HoloSphereBase extends HoloSphere$1 {
       data.id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
     const path = buildPath(this.config.appName, holonId, lensName, data.id);
+    this._log("DEBUG", "write", { holonId, lensName, dataId: data.id, path });
     const existingData = await read(this.client, path);
     if (existingData && existingData.hologram === true && existingData.target) {
       const hologramStructureFields = ["hologram", "soul", "target", "id", "_meta"];
@@ -37135,8 +37420,15 @@ class HoloSphereBase extends HoloSphere$1 {
           data.target.lensName,
           data.target.dataId
         );
+        this._log("DEBUG", "resolving hologram", {
+          hologramId: data.id,
+          sourcePath,
+          targetHolon: data.target.holonId,
+          targetLens: data.target.lensName,
+          targetDataId: data.target.dataId
+        });
         if (visited.has(sourcePath)) {
-          console.warn(`Circular hologram reference detected: ${sourcePath}`);
+          this._log("WARN", "Circular hologram reference detected", { sourcePath });
           return null;
         }
         visited.add(sourcePath);
@@ -37146,6 +37438,7 @@ class HoloSphereBase extends HoloSphere$1 {
           resolveOptions.includeAuthor = true;
         }
         const sourceData = await read(this.client, sourcePath, resolveOptions);
+        this._log("DEBUG", "hologram source fetched", { found: !!sourceData, sourcePath });
         if (sourceData) {
           let resolvedSource = sourceData;
           if (sourceData.hologram === true && sourceData.target) {
@@ -37203,13 +37496,18 @@ class HoloSphereBase extends HoloSphere$1 {
     let result;
     if (dataId) {
       const path = buildPath(this.config.appName, holonId, lensName, dataId);
+      this._log("DEBUG", "read", { holonId, lensName, dataId, path });
       result = await read(this.client, path);
+      this._log("DEBUG", "read result", { found: !!result, isHologram: result?.hologram === true });
     } else {
       const path = buildPath(this.config.appName, holonId, lensName);
+      this._log("DEBUG", "readAll", { holonId, lensName, path });
       result = await readAll(this.client, path);
+      this._log("DEBUG", "readAll result", { count: Array.isArray(result) ? result.length : 0 });
     }
     const { resolveHolograms = true } = options;
-    if (resolveHolograms) {
+    if (resolveHolograms && result) {
+      this._log("DEBUG", "resolving holograms", { itemCount: Array.isArray(result) ? result.length : 1 });
       result = await this._resolveHolograms(result);
     }
     const endTime = Date.now();
@@ -37972,4 +38270,4 @@ export {
   exists as y,
   bytes as z
 };
-//# sourceMappingURL=index-d6f4RJBM.js.map
+//# sourceMappingURL=index-4XHHKe6S.js.map