holosphere 2.0.0-alpha16 → 2.0.0-alpha18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "2.0.0-alpha16",
+  "version": "2.0.0-alpha18",
   "description": "Holonic geospatial communication infrastructure combining H3 hexagonal indexing with distributed P2P storage",
   "type": "module",
   "bin": {

package/src/index.js

@@ -875,21 +875,22 @@ class HoloSphereBase extends HoloSphereCore {
   }
 
   /**
-   * Recursively resolves holograms (references) to their source data.
-   * Handles circular reference detection and local overrides.
+   * Resolves holograms (references) to their source data.
+   * Iterates arrays and filters out invalid entries; delegates individual
+   * hologram resolution (including capability verification and recursive
+   * chain resolution) to federation.resolveHologram().
    *
    * @private
    * @param {Object|Array|null} data - Data that may contain holograms
-   * @param {Set<string>} [visited=new Set()] - Set of visited paths for circular detection
    * @returns {Promise<Object|Array|null>} Resolved data with holograms replaced by source data
    */
-  async _resolveHolograms(data, visited = new Set()) {
+  async _resolveHolograms(data) {
     if (!data) return data;
 
     if (Array.isArray(data)) {
       const resolved = [];
       for (const item of data) {
-        const resolvedItem = await this._resolveHolograms(item, new Set());
+        const resolvedItem = await this._resolveHolograms(item);
         if (resolvedItem !== null) {
           resolved.push(resolvedItem);
         }
@@ -897,81 +898,13 @@ class HoloSphereBase extends HoloSphereCore {
       return resolved;
     }
 
-    if (data && typeof data === 'object') {
-      if (data.hologram === true && data.target) {
-        const sourcePath = storage.buildPath(
-          data.target.appname || this.config.appName,
-          data.target.holonId,
-          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
-        });
-
-        // Circular reference detection
-        if (visited.has(sourcePath)) {
-          this._log('WARN', 'Circular hologram reference detected', { sourcePath });
-          return null;
-        }
-        visited.add(sourcePath);
-
-        let resolveOptions = {};
-        if (data.target.authorPubKey) {
-          resolveOptions.authors = [data.target.authorPubKey];
-          resolveOptions.includeAuthor = true;
-        }
-
-        const sourceData = await storage.read(this.client, sourcePath, resolveOptions);
-        this._log('DEBUG', 'hologram source fetched', { found: !!sourceData, sourcePath });
-        if (sourceData) {
-          // If source is also a hologram, recursively resolve it
-          let resolvedSource = sourceData;
-          if (sourceData.hologram === true && sourceData.target) {
-            resolvedSource = await this._resolveHolograms(sourceData, visited);
-            if (resolvedSource === null) {
-              return null; // Circular reference or unresolvable
-            }
-          }
-
-          // Get local override fields from the hologram (excluding hologram structure fields)
-          const hologramStructureFields = ['hologram', 'soul', 'target', '_meta', 'id', 'capability', 'crossHolosphere'];
-          const localOverrides = {};
-          for (const [k, v] of Object.entries(data)) {
-            if (!hologramStructureFields.includes(k)) {
-              localOverrides[k] = v;
-            }
-          }
-
-          const merged = {
-            ...resolvedSource,
-            ...localOverrides,
-            _hologram: {
-              isHologram: true,
-              soul: data.soul,
-              sourceHolon: data.target.holonId,
-              source: data.target,
-              localOverrides: Object.keys(localOverrides),
-              crossHolosphere: data.crossHolosphere || false,
-            }
-          };
-
-          // Preserve source _meta but add hologram source info
-          if (resolvedSource._meta) {
-            merged._meta = { ...resolvedSource._meta, source: data.target.holonId };
-          } else {
-            merged._meta = { source: data.target.holonId };
-          }
-
-          return merged;
-        }
-        return null; // Source not found
-      }
+    if (data?.hologram === true && data.target) {
+      return federation.resolveHologram(this.client, data, new Set(), [], {
+        appname: this.config.appName,
+        deleteCircular: false,
+      });
     }
+
     return data;
   }
 
@@ -1098,7 +1031,7 @@ class HoloSphereBase extends HoloSphereCore {
           this.config.appName
         );
         const fedAuthorsTimeout = new Promise((resolve) =>
-          setTimeout(() => resolve([]), 5000) // 5 second timeout, resolve with empty array
+          setTimeout(() => resolve([]), 1000) // 1 second timeout, resolve with empty array
         );
         const federatedAuthors = await Promise.race([fedAuthorsPromise, fedAuthorsTimeout]);
         this._log('DEBUG', '✅ Got federated authors', { count: federatedAuthors?.length || 0 });
@@ -2311,17 +2244,18 @@ class HoloSphereBase extends HoloSphereCore {
       throw new TypeError('callback must be a function');
     }
     const path = storage.buildPath(this.config.appName, holonId, lensName);
-    const subscriptionOptions = { realtimeOnly: true, ...options };
+    const subscriptionOptions = { realtimeOnly: true, appname: this.config.appName, ...options };
     const subscriptionId = `${holonId}-${lensName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     let innerSubscription = null;
     let unsubscribeCalled = false;
 
     (async () => {
       try {
-        // Authorization check — mirrors read() logic
-        const targetPubkey = await this._resolveHolonToPubkey(holonId);
-        const isOtherAuthor = targetPubkey && targetPubkey !== this.client.publicKey;
+        // Quick sync check: 64-char hex pubkeys different from ours are clearly other-author
+        const isPubkeyHolon = typeof holonId === 'string' && /^[0-9a-f]{64}$/i.test(holonId);
+        const isOtherAuthor = isPubkeyHolon && holonId !== this.client.publicKey;
 
+        // For other-author subscriptions, do authorization check before creating subscription
         if (isOtherAuthor) {
           const capToken = options.capabilityToken || options.capability;
           if (capToken) {
@@ -2331,29 +2265,52 @@ class HoloSphereBase extends HoloSphereCore {
               return;
             }
           } else {
-            const capability = await this._getCapabilityForAuthor(targetPubkey, { holonId, lensName });
+            const capability = await this._getCapabilityForAuthor(holonId, { holonId, lensName });
             if (!capability) {
               this._log('WARN', '❌ Subscribe: no capability for federated author - skipping', {
-                holonId, lensName, targetPubkey: targetPubkey?.slice(0, 12) + '...'
+                holonId, lensName, targetPubkey: holonId?.slice(0, 12) + '...'
               });
               return;
             }
             this._log('DEBUG', '✅ Subscribe: capability found for federated author', {
-              holonId, lensName, targetPubkey: targetPubkey?.slice(0, 12) + '...'
+              holonId, lensName, targetPubkey: holonId?.slice(0, 12) + '...'
             });
           }
         }
 
         if (unsubscribeCalled) return;
 
+        // Create subscription immediately with own public key as author filter
+        subscriptionOptions.authors = [this.client.publicKey];
+
         const subscription = await subscriptions.createSubscription(
           this.client, path, callback, subscriptionOptions
         );
         innerSubscription = subscription;
         if (unsubscribeCalled) {
           subscription.unsubscribe();
-        } else {
-          this.subscriptionRegistry.register(subscriptionId, subscription);
+          return;
+        }
+        this.subscriptionRegistry.register(subscriptionId, subscription);
+
+        // Post-setup enhancement: include federated authors
+        // Own-data subscription is already active; this adds partner visibility
+        if (!isOtherAuthor) {
+          try {
+            const fedAuthorsPromise = registry.getFederatedAuthors(
+              this.client,
+              this.config.appName
+            );
+            const fedAuthorsTimeout = new Promise((resolve) =>
+              setTimeout(() => resolve([]), 1000)
+            );
+            const federatedAuthors = await Promise.race([fedAuthorsPromise, fedAuthorsTimeout]);
+            if (federatedAuthors.length > 0) {
+              this._log('DEBUG', 'Subscribe: federated authors found post-setup', { count: federatedAuthors.length });
+            }
+          } catch (err) {
+            this._log('WARN', 'Failed to get federated authors for subscription', { error: err.message });
+          }
         }
       } catch (err) {
         this._log('ERROR', 'Subscription setup failed', { path, error: err.message });

package/src/storage/nostr-async.js

@@ -878,8 +878,11 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
   const pathParts = pathPrefix.split('/');
   const targetAuthor = pathParts[1] || client.publicKey;
 
-  // Create unique key for this subscription (use target author, not client pubkey)
-  const subscriptionKey = `${targetAuthor}:${kind}:${pathPrefix}`;
+  // Use provided authors list (includes federated partners) or fall back to target author only
+  const allAuthors = options.authors || [targetAuthor];
+
+  // Create unique key for this subscription (include all authors to avoid conflicts)
+  const subscriptionKey = `${allAuthors.join(',')}:${kind}:${pathPrefix}`;
 
   // Check if we already have an active subscription for this path
   const existingSub = globalSubscriptions.get(subscriptionKey);
@@ -921,8 +924,8 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
     }
     seenEventIds.add(event.id);
 
-    // Check if event is from a different author (relay not respecting filter)
-    if (event.pubkey !== targetAuthor) {
+    // Check if event is from an allowed author (relay not respecting filter)
+    if (!allAuthors.includes(event.pubkey)) {
       rejectedCount++;
 
       // Only log periodically to avoid spam
@@ -931,7 +934,7 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
         console.warn('[nostrSubscribeMany] ⚠️ Relay not respecting authors filter!', {
           rejectedCount,
           acceptedCount,
-          expected: targetAuthor,
+          expectedAuthors: allAuthors.length,
           message: 'Consider using a different relay or implementing private relay'
         });
         lastLogTime = now;
@@ -966,13 +969,14 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
 
   // Subscribe to data events (kind 30000) for initial load
   // Use 'since' to only get events from subscription time onward for real-time updates
-  const subscriptionStartTime = Math.floor(Date.now() / 1000);
+  // Subtract 2 seconds to capture events written during async subscription setup
+  // (the subscribe() IIFE in index.js does auth/federation lookups before reaching here)
+  const subscriptionStartTime = Math.floor(Date.now() / 1000) - 2;
   const dataFilter = {
     kinds: [kind],
-    authors: [targetAuthor],  // Use target author (holon ID), not client pubkey
+    authors: allAuthors,  // Include target author + federated partners
     since: subscriptionStartTime  // Only get new events after subscription
   };
-  console.log('[nostrSubscribeMany] Subscribing to:', { pathPrefix, targetAuthor: targetAuthor.slice(0, 12), clientPubKey: client.publicKey.slice(0, 12) });
   const dataSubscription = await client.subscribe(dataFilter, handleDataEvent);
 
   // Use Page Visibility API to refresh when tab becomes visible

package/src/storage/nostr-client.js

@@ -523,8 +523,11 @@ export class NostrClient {
           dataDir: this.config.dataDir
         });
 
-        // Load cached events from persistent storage
-        await this._loadFromPersistentStorage();
+        // Load cached events from persistent storage in background
+        // (non-blocking to avoid stalling _initReady with large data sets)
+        this._loadFromPersistentStorage().catch(err => {
+          console.warn('Background persistent storage load failed:', err);
+        });
 
         // Initialize outbox queue for guaranteed delivery
         this.outboxQueue = new OutboxQueue(this.persistentStorage, {

package/src/subscriptions/manager.js

@@ -23,7 +23,7 @@ import { resolveHologram } from '../federation/hologram.js';
  * @returns {Promise<Object>} Subscription object with path and unsubscribe method
  */
 export async function createSubscription(client, path, callback, options = {}) {
-  const { throttle = 0, filter = null, includeFederated = false, triggerInitial = false, realtimeOnly = true, resolveHolograms = true } = options;
+  const { throttle = 0, filter = null, includeFederated = false, triggerInitial = false, realtimeOnly = true, resolveHolograms = true, appname = null } = options;
 
   let lastInvoke = 0;
   let timeoutId = null;
@@ -48,13 +48,22 @@ export async function createSubscription(client, path, callback, options = {}) {
     let resolvedData = data;
     if (resolveHolograms && data && data.hologram === true) {
       try {
-        resolvedData = await resolveHologram(client, data);
+        resolvedData = await resolveHologram(client, data, undefined, undefined, { appname });
         // If resolution failed, skip this item (source data may not exist yet)
         if (!resolvedData) {
+          console.debug('[subscription] Hologram resolution returned null, skipping:', {
+            id: data.id,
+            soul: data.soul,
+            target: data.target?.holonId?.slice(0, 12)
+          });
           return;
         }
       } catch (err) {
-        console.warn('Failed to resolve hologram in subscription:', err);
+        console.warn('Failed to resolve hologram in subscription:', err, {
+          id: data?.id,
+          soul: data?.soul,
+          target: data?.target?.holonId?.slice(0, 12)
+        });
         return;
       }
     }
@@ -85,7 +94,7 @@ export async function createSubscription(client, path, callback, options = {}) {
   };
 
   // Subscribe using Nostr wrapper
-  const subscription = await subscribe(client, path, wrappedCallback, { realtimeOnly });
+  const subscription = await subscribe(client, path, wrappedCallback, { realtimeOnly, ...(options.authors && { authors: options.authors }) });
 
   // Return subscription object
   return {