holosphere 2.0.0-alpha6 → 2.0.0-alpha7

package/package.json

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

package/src/storage/gun-async.js

@@ -101,22 +101,24 @@ export async function gunMap(gunChain, timeout = 5000) {
         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-collect inline items (not Gun references)
+      for (const key of keys) {
+        const rawItem = parentData[key];
+        if (!rawItem) continue;
+
+        // Skip Gun references - will be fetched via map().once()
+        if (typeof rawItem === 'object' && rawItem['#']) continue;
+
+        items[key] = rawItem;
       }
 
-      // Step 2: Collect items, counting as we go
+      // Expected count is ALL keys (map().once() fires for all)
+      expectedCount = keys.length;
+
+      // Step 2: Collect items via map().once(), counting as we go
       gunChain.map().once((data, key) => {
         if (settled || !data || key.startsWith('_')) return;
+        // Add/update the item (inline items may be updated by map().once())
         items[key] = data;
         receivedCount++;
         tryResolve();

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

@@ -210,19 +210,7 @@ export async function readAll(gun, path, timeout = 5000) {
     };
 
     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
@@ -257,40 +245,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();
       });
     });