holosphere 1.3.0-alpha0 → 1.3.0-alpha4

package/content.js

@@ -1,5 +1,64 @@
 // holo_content.js
 
+/**
+ * Recursively sanitizes a value for storage in GunDB.
+ *
+ * Drops keys whose values would corrupt the graph or round-trip incorrectly:
+ *   - undefined, NaN, Infinity, -Infinity (JSON.stringify silently turns
+ *     these into nothing or "null", which is how malformed payloads like
+ *     `"initiated":,` end up in the graph and surface later as per-character
+ *     parse warnings).
+ *   - functions, symbols, bigints (not JSON-representable).
+ * Preserves null (legitimate Gun tombstone / explicit empty value).
+ * Guards against circular references.
+ *
+ * Logs one warning per dropped path so the caller can fix the producer.
+ */
+function sanitizeForStorage(value, path = '', seen = new WeakSet(), warnings = []) {
+    if (value === null) return null;
+    const t = typeof value;
+
+    if (t === 'number') {
+        if (!Number.isFinite(value)) {
+            warnings.push(`${path || '<root>'}: ${value} (non-finite number)`);
+            return undefined;
+        }
+        return value;
+    }
+    if (t === 'string' || t === 'boolean') return value;
+    if (t === 'undefined' || t === 'function' || t === 'symbol' || t === 'bigint') {
+        warnings.push(`${path || '<root>'}: ${t}`);
+        return undefined;
+    }
+
+    if (t === 'object') {
+        if (seen.has(value)) {
+            warnings.push(`${path || '<root>'}: circular reference`);
+            return undefined;
+        }
+        seen.add(value);
+
+        if (Array.isArray(value)) {
+            const out = [];
+            for (let i = 0; i < value.length; i++) {
+                const cleaned = sanitizeForStorage(value[i], `${path}[${i}]`, seen, warnings);
+                out.push(cleaned === undefined ? null : cleaned);
+            }
+            return out;
+        }
+
+        const out = {};
+        for (const k of Object.keys(value)) {
+            const cleaned = sanitizeForStorage(value[k], path ? `${path}.${k}` : k, seen, warnings);
+            if (cleaned !== undefined) out[k] = cleaned;
+        }
+        return out;
+    }
+
+    warnings.push(`${path || '<root>'}: unsupported type ${t}`);
+    return undefined;
+}
+
 /**
  * Stores content in the specified holon and lens.
  * If the target path already contains a hologram, the put operation will be
@@ -142,11 +201,21 @@ export async function put(holoInstance, holon, lens, data, password = null, opti
 
         return new Promise((resolve, reject) => {
             try {
-                // Create a copy of data without the _meta field if it exists
-                let dataToStore = { ...data };
-                if (dataToStore._meta !== undefined) {
-                    delete dataToStore._meta;
+                // Sanitize before serialization so undefined/NaN/Infinity etc.
+                // can never produce a malformed payload like `"initiated":,`
+                // (which is what causes per-character parse warnings on read).
+                const sanitizeWarnings = [];
+                let dataToStore = sanitizeForStorage(data, '', new WeakSet(), sanitizeWarnings) || {};
+                if (sanitizeWarnings.length > 0) {
+                    console.warn(
+                        `holosphere.put: sanitized ${sanitizeWarnings.length} field(s) at ${targetHolon}/${targetLens}/${targetKey} (id=${data.id}):`,
+                        sanitizeWarnings
+                    );
                 }
+                // Strip read-side envelopes that must never be persisted
+                // (they're attached at resolution time).
+                if (dataToStore._meta !== undefined) delete dataToStore._meta;
+                if (dataToStore._hologram !== undefined) delete dataToStore._hologram;
                 const payload = JSON.stringify(dataToStore); // The data being stored
 
                 const putCallback = async (ack) => {
@@ -514,8 +583,12 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                 user.get('private').get(lens) :
                 holoInstance.gun.get(holoInstance.appname).get(holon).get(lens);
 
-            // PASS 1: Get shallow node to determine expected item count
-            dataPath.once((data) => {
+            // PASS 1: Get shallow node to determine expected item count.
+            // Retry once if empty — Gun's .once() reads from local cache, which
+            // may be cold immediately after startup before peers have synced.
+            const shallowOnce = () => new Promise((res) => dataPath.once((d) => res(d)));
+
+            const processShallow = (data) => {
                 if (!data) {
                     resolve([]);
                     return;
@@ -537,81 +610,90 @@ export async function getAll(holoInstance, holon, lens, password = null) {
                     return;
                 }
 
-                // PASS 2: Use map().once() to iterate and get full item data
-                let receivedCount = 0;
-
-                dataPath.map().once(async (itemData, key) => {
-                    if (!itemData || key === '_') {
-                        receivedCount++;
-                        if (receivedCount >= expectedCount) {
-                            await Promise.all(pendingProcessing);
-                            resolve(Array.from(output.values()));
-                        }
-                        return;
-                    }
+                // PASS 2: iterate explicitly over the filtered keys.
+                // Using dataPath.map().once() here is unsafe when the parent
+                // node has tombstoned siblings (null values): map() fires for
+                // every child, and a null sibling's callback can satisfy
+                // receivedCount before real items are processed, resolving [].
+                const processItem = async (itemData, key) => {
+                    if (!itemData) return;
+                    try {
+                        const parsed = await holoInstance.parse(itemData);
+                        if (!parsed || !parsed.id) return;
 
-                    const processingPromise = (async () => {
-                        try {
-                            const parsed = await holoInstance.parse(itemData);
-                            if (!parsed || !parsed.id) return;
-
-                            if (holoInstance.isHologram(parsed)) {
-                                try {
-                                    const resolved = await holoInstance.resolveHologram(parsed, {
-                                        followHolograms: true,
-                                        maxDepth: 10,
-                                        currentDepth: 0
-                                    });
+                        if (holoInstance.isHologram(parsed)) {
+                            try {
+                                const resolved = await holoInstance.resolveHologram(parsed, {
+                                    followHolograms: true,
+                                    maxDepth: 10,
+                                    currentDepth: 0
+                                });
 
-                                    if (resolved === null) {
-                                        console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
-                                        try {
-                                            await holoInstance.delete(holon, lens, key, password);
-                                        } catch (cleanupError) {
-                                            console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
-                                        }
-                                        return;
+                                if (resolved === null) {
+                                    console.warn(`Broken hologram detected in getAll for key ${key}. Removing it...`);
+                                    try {
+                                        await holoInstance.delete(holon, lens, key, password);
+                                    } catch (cleanupError) {
+                                        console.error(`Failed to remove broken hologram at ${holon}/${lens}/${key}:`, cleanupError);
                                     }
+                                    return;
+                                }
 
-                                    if (resolved && resolved !== parsed) {
-                                        if (schema) {
-                                            const valid = holoInstance.validator.validate(schema, resolved);
-                                            if (valid || !holoInstance.strict) {
-                                                output.set(resolved.id, resolved);
-                                            }
-                                        } else {
+                                if (resolved && resolved !== parsed) {
+                                    if (schema) {
+                                        const valid = holoInstance.validator.validate(schema, resolved);
+                                        if (valid || !holoInstance.strict) {
                                             output.set(resolved.id, resolved);
                                         }
-                                        return;
+                                    } else {
+                                        output.set(resolved.id, resolved);
                                     }
-                                } catch (hologramError) {
-                                    console.error(`Error resolving hologram for key ${key}:`, hologramError);
                                     return;
                                 }
+                            } catch (hologramError) {
+                                console.error(`Error resolving hologram for key ${key}:`, hologramError);
+                                return;
                             }
+                        }
 
-                            if (schema) {
-                                const valid = holoInstance.validator.validate(schema, parsed);
-                                if (valid || !holoInstance.strict) {
-                                    output.set(parsed.id, parsed);
-                                }
-                            } else {
+                        if (schema) {
+                            const valid = holoInstance.validator.validate(schema, parsed);
+                            if (valid || !holoInstance.strict) {
                                 output.set(parsed.id, parsed);
                             }
-                        } catch (error) {
-                            console.error('Error processing data:', error);
+                        } else {
+                            output.set(parsed.id, parsed);
                         }
-                    })();
-
-                    pendingProcessing.push(processingPromise);
-                    receivedCount++;
+                    } catch (error) {
+                        console.error('Error processing data:', error);
+                    }
+                };
 
-                    if (receivedCount >= expectedCount) {
-                        await Promise.all(pendingProcessing);
-                        resolve(Array.from(output.values()));
+                Promise.all(keys.map((key) => {
+                    const inline = data[key];
+                    // If shallow already inlined the leaf (holosphere stores
+                    // payloads as JSON strings), process it directly. This
+                    // avoids a redundant round-trip and the map() race.
+                    if (typeof inline !== 'object' || inline === null) {
+                        return processItem(inline, key);
                     }
-                });
-            });
+                    // Otherwise fetch the leaf — sub-graph reference path.
+                    return new Promise((resolveItem) => {
+                        dataPath.get(key).once((itemData) => {
+                            processItem(itemData, key).then(resolveItem, resolveItem);
+                        });
+                    });
+                })).then(() => resolve(Array.from(output.values())));
+            };
+
+            (async () => {
+                let data = await shallowOnce();
+                if (!data) {
+                    await new Promise(r => setTimeout(r, 1500));
+                    data = await shallowOnce();
+                }
+                processShallow(data);
+            })();
         });
     } catch (error) {
         console.error('Error in getAll:', error);