holosphere 2.0.0-alpha6 → 2.0.0-alpha8

package/src/storage/gun-auth.js

@@ -274,28 +274,36 @@ export class GunAuth {
           return;
         }
 
-        // Count references that need fetching
-        expectedCount = keys.filter(k => {
-          const item = parentData[k];
-          return item && typeof item === 'object' && item['#'];
-        }).length;
-
-        // If no references, we're done
-        if (expectedCount === 0) {
-          settled = true;
-          resolve([]);
-          return;
-        }
+        // Pre-parse inline items (not Gun references)
+        for (const key of keys) {
+          const rawItem = parentData[key];
+          if (!rawItem) continue;
 
-        // Step 2: Collect items, counting as we go
-        ref.map().once((data, key) => {
-          if (settled || !data || key.startsWith('_') || seen.has(key)) return;
-          seen.add(key);
+          // Skip Gun references - will be fetched via map().once()
+          if (typeof rawItem === 'object' && rawItem['#']) continue;
 
-          const parsed = parseItem(data);
-          if (parsed && !parsed._deleted) {
+          const parsed = parseItem(rawItem);
+          if (parsed && !parsed._deleted && !seen.has(key)) {
+            seen.add(key);
             results.push(parsed);
           }
+        }
+
+        // Expected count is ALL keys (map().once() fires for all)
+        expectedCount = keys.length;
+
+        // Step 2: Collect items via map().once(), counting as we go
+        ref.map().once((data, key) => {
+          if (settled || !data || key.startsWith('_')) return;
+
+          // Count every item, but only add if not already seen
+          if (!seen.has(key)) {
+            seen.add(key);
+            const parsed = parseItem(data);
+            if (parsed && !parsed._deleted) {
+              results.push(parsed);
+            }
+          }
           receivedCount++;
           tryResolve();
         });

package/src/storage/gun-wrapper.js

@@ -54,15 +54,32 @@ function encodePathComponent(component) {
   return encodeURIComponent(component).replace(/%2F/g, '/');
 }
 
+/**
+ * Navigate to a Gun path using chained .get() calls
+ * Gun treats 'a/b/c' as a literal key, not a path.
+ * This function splits the path and chains .get() calls properly.
+ * @private
+ * @param {Object} gun - Gun instance
+ * @param {string} path - Path string like "appname/holon/lens/key"
+ * @returns {Object} Gun chain reference at the path
+ */
+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;
+}
+
 /**
  * Serialize data for GunDB storage
- * Wraps data in { _json: string } format for Gun compatibility
- * Gun requires an object at graph roots, so we can't store raw JSON strings
- * The deserialization handles both this format and raw JSON strings for reading old data
+ * Stores data as raw JSON string for compatibility with holosphere original
+ * This matches the format used in holosphere v1 for better interoperability
  * @private
  */
 function serializeForGun(data) {
-  return { _json: JSON.stringify(data) };
+  return JSON.stringify(data);
 }
 
 /**
@@ -152,11 +169,21 @@ function deserializeFromGun(data) {
 export async function write(gun, path, data) {
   try {
     const serialized = serializeForGun(data);
-    await gunPut(gun.get(path), serialized, 2000);
-    // Delay to allow Gun to propagate the write (50ms for better reliability)
-    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, 5000); // Increased timeout from 2s to 5s
+    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 ack info so caller can handle timeouts
+    return { ok: true, timeout: ack.timeout || false };
   } catch (error) {
+    console.error('[gun-wrapper] write error:', error);
     throw error;
   }
 }
@@ -168,7 +195,12 @@ export async function write(gun, path, data) {
  * @returns {Promise<Object|null>} Data or null if not found
  */
 export async function read(gun, path) {
-  const rawData = await gunPromise(gun.get(path), 2000);
+  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, 2000);
+  console.log('[gun-wrapper] read rawData:', rawData ? (typeof rawData === 'string' ? rawData.substring(0, 100) : 'object') : 'null');
 
   if (!rawData) {
     return null;
@@ -193,53 +225,52 @@ export async function read(gun, path) {
  * @returns {Promise<Object[]>} Array of data objects
  */
 export async function readAll(gun, path, timeout = 5000) {
+  const parts = path.split('/').filter(p => p.length > 0);
+  console.log('[gun-wrapper] readAll:', { path, parts });
+
   return new Promise((resolve) => {
     const output = 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', output.size, 'items');
         resolve(Array.from(output.values()));
       }
     };
 
     const parseItem = (data) => {
-      if (!data) return null;
-
-      let item = null;
-      if (data._json && typeof data._json === 'string') {
-        try {
-          item = JSON.parse(data._json);
-        } catch (e) {}
-      } else if (typeof data === 'string') {
-        try {
-          item = JSON.parse(data);
-        } catch (e) {}
-      }
-      return item;
+      return deserializeFromGun(data);
     };
 
     // Step 1: Get the parent data to count expected items
     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;
       }
 
       // Get all keys except Gun metadata
       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;
       }
@@ -257,40 +288,38 @@ export async function readAll(gun, path, timeout = 5000) {
           continue;
         }
 
-        // Try to parse inline data
+        // Try to parse inline data (don't count yet - will count in map().once() phase)
         const item = parseItem(rawItem);
         if (item && item.id && !item._deleted) {
           output.set(item.id, item);
-          receivedCount++;
         }
       }
 
-      // Set expected count: references that need fetching
-      expectedCount = referenceKeys.length;
+      // Set expected count: ALL keys that could have data (references + inline)
+      // We use total keys because map().once() will fire for all of them
+      expectedCount = keys.length;
 
-      // If no references to resolve, we're done
+      // If no keys, we're done (shouldn't happen but be safe)
       if (expectedCount === 0) {
         settled = true;
         resolve(Array.from(output.values()));
         return;
       }
 
-      // Step 2: Use map().once() to resolve references, counting as we go
+      // Step 2: Use map().once() to resolve all items, counting as we go
       ref.map().once((data, key) => {
         if (settled || !data || key === '_') return;
 
         const item = parseItem(data);
         if (item && item.id && !item._deleted) {
+          // Add to output if not already there (inline items already added)
           if (!output.has(item.id)) {
             output.set(item.id, item);
-            receivedCount++;
-            tryResolve();
           }
-        } else {
-          // Item was null/deleted, still count it as received
-          receivedCount++;
-          tryResolve();
         }
+        // Count every item received (inline or reference)
+        receivedCount++;
+        tryResolve();
       });
     });
 
@@ -312,7 +341,7 @@ export async function readAll(gun, path, timeout = 5000) {
  * @returns {Promise<boolean>} Success indicator
  */
 export async function update(gun, path, updates) {
-  const rawData = await gunPromise(gun.get(path));
+  const rawData = await gunPromise(getGunPath(gun, path));
 
   if (!rawData) {
     return false; // Not found
@@ -329,7 +358,9 @@ export async function update(gun, path, updates) {
 
   try {
     const serialized = serializeForGun(merged);
-    await gunPut(gun.get(path), serialized);
+    await gunPut(getGunPath(gun, path), serialized, 2000);
+    // Add delay for propagation
+    await new Promise(resolve => setTimeout(resolve, 200));
     return true;
   } catch (error) {
     throw error;
@@ -345,7 +376,7 @@ export async function update(gun, path, updates) {
 export async function deleteData(gun, path) {
   try {
     // First read existing data to get the id
-    const rawData = await gunPromise(gun.get(path));
+    const rawData = await gunPromise(getGunPath(gun, path));
     if (!rawData) {
       return true; // Already deleted/doesn't exist
     }
@@ -359,7 +390,9 @@ export async function deleteData(gun, path) {
       _deletedAt: Date.now()
     };
 
-    await gunPut(gun.get(path), serializeForGun(tombstone));
+    await gunPut(getGunPath(gun, path), serializeForGun(tombstone), 2000);
+    // Add delay for propagation
+    await new Promise(resolve => setTimeout(resolve, 200));
     return true;
   } catch (error) {
     throw error;
@@ -403,7 +436,7 @@ export function subscribe(gun, path, callback, options = {}) {
 
   if (isPrefix) {
     // Subscribe to all items under this prefix
-    const ref = gun.get(path);
+    const ref = getGunPath(gun, path);
 
     ref.map().on((data, key) => {
       if (data && !key.startsWith('_')) {
@@ -425,7 +458,7 @@ export function subscribe(gun, path, callback, options = {}) {
     };
   } else {
     // Subscribe to single item
-    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) {
@@ -464,6 +497,7 @@ export async function writeGlobal(gun, appname, tableName, data) {
     throw new Error('writeGlobal: data must have an id field');
   }
   const path = buildGlobalPath(appname, tableName, data.id);
+  // Use write function which includes the propagation delay
   return write(gun, path, data);
 }
 

package/src/storage/nostr-async.js

@@ -65,28 +65,33 @@ export async function nostrGet(client, path, kind = 30000, options = {}) {
   if (!options.skipPersistent && client.persistentGet) {
     const persistedEvent = await client.persistentGet(path);
     if (persistedEvent && persistedEvent.content) {
-      try {
-        const data = JSON.parse(persistedEvent.content);
+      // Verify author is in requested authors list (persistent storage may have cached events from other authors)
+      if (!authors.includes(persistedEvent.pubkey)) {
+        // Author mismatch - fall through to relay query
+      } else {
+        try {
+          const data = JSON.parse(persistedEvent.content);
 
-        // Skip deleted items
-        if (data._deleted) {
-          return null;
-        }
+          // Skip deleted items
+          if (data._deleted) {
+            return null;
+          }
 
-        // Optionally include author information
-        if (options.includeAuthor) {
-          data._author = persistedEvent.pubkey;
-        }
+          // Optionally include author information
+          if (options.includeAuthor) {
+            data._author = persistedEvent.pubkey;
+          }
 
-        // Trigger background refresh from relays (fire-and-forget)
-        if (client.refreshPathInBackground) {
-          client.refreshPathInBackground(path, kind, { authors, timeout });
-        }
+          // Trigger background refresh from relays (fire-and-forget)
+          if (client.refreshPathInBackground) {
+            client.refreshPathInBackground(path, kind, { authors, timeout });
+          }
 
-        return data;
-      } catch (error) {
-        // Fall through to relay query if parsing fails
-        console.warn('[nostrGet] Failed to parse persisted event:', error);
+          return data;
+        } catch (error) {
+          // Fall through to relay query if parsing fails
+          console.warn('[nostrGet] Failed to parse persisted event:', error);
+        }
       }
     }
   }
@@ -136,12 +141,15 @@ async function _executeNostrGet(client, path, kind, authors, timeout, options) {
 
   const events = await client.query(filter, { timeout });
 
-  if (events.length === 0) {
+  // Filter by author (relays may not respect authors filter)
+  const authoredEvents = events.filter(event => authors.includes(event.pubkey));
+
+  if (authoredEvents.length === 0) {
     return null;
   }
 
-  // Get most recent event (across all authors)
-  const event = events.sort((a, b) => b.created_at - a.created_at)[0];
+  // Get most recent event (across allowed authors)
+  const event = authoredEvents.sort((a, b) => b.created_at - a.created_at)[0];
 
   try {
     const data = JSON.parse(event.content);
@@ -187,6 +195,9 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
       for (const event of persistedEvents) {
         if (!event || !event.tags) continue;
 
+        // Verify author is in requested authors list (persistent storage may have cached events from other authors)
+        if (!authors.includes(event.pubkey)) continue;
+
         const dTag = event.tags.find(t => t[0] === 'd');
         if (!dTag || !dTag[1] || !dTag[1].startsWith(pathPrefix)) continue;
 
@@ -267,10 +278,12 @@ async function _executeNostrGetAll(client, pathPrefix, kind, authors, timeout, l
 
   const events = await client.query(filter, { timeout });
 
-  // Filter by path prefix in application layer
+  // Filter by path prefix AND verify author (relays may not respect authors filter)
   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;
   });
 
   // Parse content and group by d-tag (keep latest only, across all authors)
@@ -331,10 +344,12 @@ export async function nostrGetAllHybrid(client, pathPrefix, kind = 30000, option
 
   const events = await queryMethod.call(client, filter, { timeout });
 
-  // Filter by path prefix in application layer
+  // Filter by path prefix AND verify author (relays may not respect authors filter)
   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;
   });
 
   // Parse content and group by d-tag (keep latest only)

package/src/storage/unified-storage.js

@@ -27,7 +27,11 @@ export function buildPath(appName, holonId, lensName, key = null) {
  * @returns {Promise<boolean>} Success indicator
  */
 export async function write(client, path, data) {
-  // Check if this is a GunDB client
+  // Check if this is a GunDB client with backend methods (preferred - has write cache)
+  if (client.write && client.gun) {
+    return client.write(path, data);
+  }
+  // Fallback to direct gunWrapper (no write cache)
   if (client.gun) {
     return gunWrapper.write(client.gun, path, data);
   }
@@ -43,6 +47,11 @@ export async function write(client, path, data) {
  * @returns {Promise<Object|null>} Data or null
  */
 export async function read(client, path, options = {}) {
+  // Check if this is a GunDB client with backend methods (preferred - has write cache)
+  if (client.read && client.gun) {
+    return client.read(path, options);
+  }
+  // Fallback to direct gunWrapper
   if (client.gun) {
     return gunWrapper.read(client.gun, path);
   }
@@ -57,6 +66,11 @@ export async function read(client, path, options = {}) {
  * @returns {Promise<Object[]>} Array of data objects
  */
 export async function readAll(client, path, options = {}) {
+  // Check if this is a GunDB client with backend methods (preferred - has write cache)
+  if (client.readAll && client.gun) {
+    return client.readAll(path, options);
+  }
+  // Fallback to direct gunWrapper
   if (client.gun) {
     return gunWrapper.readAll(client.gun, path);
   }
@@ -71,6 +85,11 @@ export async function readAll(client, path, options = {}) {
  * @returns {Promise<boolean>} Success indicator
  */
 export async function update(client, path, updates) {
+  // Check if this is a GunDB client with backend methods (preferred - has write cache)
+  if (client.update && client.gun) {
+    return client.update(path, updates);
+  }
+  // Fallback to direct gunWrapper
   if (client.gun) {
     return gunWrapper.update(client.gun, path, updates);
   }
@@ -84,6 +103,11 @@ export async function update(client, path, updates) {
  * @returns {Promise<boolean>} Success indicator
  */
 export async function deleteData(client, path) {
+  // Check if this is a GunDB client with backend methods (preferred - has write cache)
+  if (client.delete && client.gun) {
+    return client.delete(path);
+  }
+  // Fallback to direct gunWrapper
   if (client.gun) {
     return gunWrapper.deleteData(client.gun, path);
   }
@@ -97,6 +121,7 @@ export async function deleteData(client, path) {
  * @returns {Promise<Object>} Deletion results
  */
 export async function deleteAll(client, path) {
+  // Fallback to direct gunWrapper (deleteAll not typically in client interface)
   if (client.gun) {
     return gunWrapper.deleteAll(client.gun, path);
   }
@@ -112,6 +137,11 @@ export async function deleteAll(client, path) {
  * @returns {Object} Subscription with unsubscribe method
  */
 export function subscribe(client, path, callback, options = {}) {
+  // Check if this is a GunDB client with backend methods
+  if (client.subscribe && client.gun) {
+    return client.subscribe(path, callback, options);
+  }
+  // Fallback to direct gunWrapper
   if (client.gun) {
     return gunWrapper.subscribe(client.gun, path, callback, options);
   }

package/vite.config.cdn.js

@@ -0,0 +1,60 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+
+/**
+ * CDN Build Configuration
+ * Creates a self-contained bundle for browser usage via CDN
+ * All dependencies are bundled (no externals)
+ */
+export default defineConfig({
+  build: {
+    target: 'es2020',
+    outDir: 'dist/cdn',
+    lib: {
+      entry: resolve(__dirname, 'src/cdn-entry.js'),
+      name: 'HoloSphere',
+      formats: ['iife'],
+      fileName: () => 'holosphere.min.js',
+    },
+    rollupOptions: {
+      // Bundle all dependencies for CDN
+      external: [],
+      output: {
+        // Use default export so HoloSphere is directly accessible
+        exports: 'default',
+        // Extend window with all exports
+        extend: true,
+        // Provide globals for any remaining externals
+        globals: {},
+        // Inline dynamic imports
+        inlineDynamicImports: true,
+      },
+    },
+    sourcemap: true,
+    minify: 'terser',
+    terserOptions: {
+      compress: {
+        drop_console: false,
+        passes: 2,
+      },
+      mangle: {
+        safari10: true,
+      },
+    },
+    // Increase chunk size warning limit for CDN bundle
+    chunkSizeWarningLimit: 2000,
+  },
+  resolve: {
+    alias: [
+      {
+        find: './filesystem-storage.js',
+        replacement: resolve(__dirname, 'src/storage/filesystem-storage-browser.js'),
+      },
+    ],
+  },
+  define: {
+    'process.versions.node': JSON.stringify(undefined),
+    'process.env.NODE_ENV': JSON.stringify('production'),
+    'global': 'globalThis',
+  },
+});