holosphere 1.1.0 → 1.1.2

package/holosphere.js

@@ -3,6 +3,7 @@ import OpenAI from 'openai';
 import Gun from 'gun'
 import Ajv2019 from 'ajv/dist/2019.js'
 
+
 class HoloSphere {
     /**
      * Initializes a new instance of the HoloSphere class.
@@ -13,13 +14,13 @@ class HoloSphere {
     constructor(appname, strict = false, openaikey = null) {
         this.appname = appname
         this.strict = strict;
-        this.validator = new Ajv2019({ 
+        this.validator = new Ajv2019({
             allErrors: true,
             strict: false,  // Keep this false to avoid Ajv strict mode issues
             validateSchema: true // Always validate schemas
         });
         this.gun = Gun({
-            peers: ['http://gun.holons.io', 'https://59.src.eco/gun'],
+            peers: ['https://gun.holons.io/gun', 'https://59.src.eco/gun'],
             axe: false,
             // uuid: (content) => { // generate a unique id for each node
             //     console.log('uuid', content);
@@ -31,6 +32,8 @@ class HoloSphere {
                 apiKey: openaikey,
             });
         }
+
+        this.subscriptions = new Map(); // Track active subscriptions
     }
 
     // ================================ SCHEMA FUNCTIONS ================================
@@ -43,64 +46,52 @@ class HoloSphere {
      */
     async setSchema(lens, schema) {
         if (!lens || !schema) {
-            console.error('setSchema: Missing required parameters');
-            return false;
+            throw new Error('setSchema: Missing required parameters');
         }
 
-        // Basic schema validation - check for required fields
+        // Basic schema validation
         if (!schema.type || typeof schema.type !== 'string') {
-            console.error('setSchema: Schema must have a type field');
-            return false;
+            throw new Error('setSchema: Schema must have a type field');
         }
 
         if (this.strict) {
-            try {
-                // Validate schema against JSON Schema meta-schema
-                const metaSchema = {
-                    type: 'object',
-                    required: ['type', 'properties'],
+            const metaSchema = {
+                type: 'object',
+                required: ['type', 'properties'],
+                properties: {
+                    type: { type: 'string' },
                     properties: {
-                        type: { type: 'string' },
-                        properties: { 
+                        type: 'object',
+                        additionalProperties: {
                             type: 'object',
-                            additionalProperties: {
-                                type: 'object',
-                                required: ['type'],
-                                properties: {
-                                    type: { type: 'string' }
-                                }
+                            required: ['type'],
+                            properties: {
+                                type: { type: 'string' }
                             }
-                        },
-                        required: {
-                            type: 'array',
-                            items: { type: 'string' }
                         }
+                    },
+                    required: {
+                        type: 'array',
+                        items: { type: 'string' }
                     }
-                };
-
-                const valid = this.validator.validate(metaSchema, schema);
-                if (!valid) {
-                    console.error('setSchema: Invalid schema structure:', this.validator.errors);
-                    return false;
                 }
+            };
 
-                // Additional strict mode checks
-                if (!schema.properties || typeof schema.properties !== 'object') {
-                    console.error('setSchema: Schema must have properties in strict mode');
-                    return false;
-                }
+            const valid = this.validator.validate(metaSchema, schema);
+            if (!valid) {
+                throw new Error(`Invalid schema structure: ${JSON.stringify(this.validator.errors)}`);
+            }
 
-                if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
-                    console.error('setSchema: Schema must have required fields in strict mode');
-                    return false;
-                }
-            } catch (error) {
-                console.error('setSchema: Schema validation error:', error);
-                return false;
+            if (!schema.properties || typeof schema.properties !== 'object') {
+                throw new Error('Schema must have properties in strict mode');
+            }
+
+            if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
+                throw new Error('Schema must have required fields in strict mode');
             }
         }
 
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             try {
                 const schemaString = JSON.stringify(schema);
                 this.gun.get(this.appname)
@@ -108,16 +99,13 @@ class HoloSphere {
                     .get('schema')
                     .put(schemaString, ack => {
                         if (ack.err) {
-                            console.error('Failed to add schema:', ack.err);
-                            resolve(false);
+                            reject(new Error(ack.err));
                         } else {
-                            console.log('Schema added successfully for lens:', lens);
                             resolve(true);
                         }
                     });
             } catch (error) {
-                console.error('setSchema: Error stringifying schema:', error);
-                resolve(false);
+                reject(error);
             }
         });
     }
@@ -129,8 +117,7 @@ class HoloSphere {
      */
     async getSchema(lens) {
         if (!lens) {
-            console.error('getSchema: Missing lens parameter');
-            return null;
+            throw new Error('getSchema: Missing lens parameter');
         }
 
         return new Promise((resolve) => {
@@ -142,21 +129,17 @@ class HoloSphere {
                         resolve(null);
                         return;
                     }
-                    
+
                     try {
-                        // If data is already a string, parse it
-                        if (typeof data === 'string') {
-                            resolve(JSON.parse(data));
-                        } 
-                        // If data is an object with a string value (GunDB format)
-                        else if (typeof data === 'object' && data !== null) {
-                            const schemaStr = Object.values(data).find(v => 
-                                typeof v === 'string' && v.includes('"type":')); 
-                            if (schemaStr) {
-                                resolve(JSON.parse(schemaStr));
-                            } else {
-                                resolve(null);
-                            }
+                        // Handle both direct string and GunDB object formats
+                        let schemaStr = data;
+                        if (typeof data === 'object' && data !== null) {
+                            schemaStr = Object.values(data).find(v => 
+                                typeof v === 'string' && v.includes('"type":'));
+                        }
+
+                        if (schemaStr) {
+                            resolve(JSON.parse(schemaStr));
                         } else {
                             resolve(null);
                         }
@@ -179,53 +162,43 @@ class HoloSphere {
      */
     async put(holon, lens, data) {
         if (!holon || !lens || !data) {
-            console.error('put: Missing required parameters:', { holon, lens, data });
-            return false;
+            throw new Error('put: Missing required parameters');
         }
 
         if (!data.id) {
-            console.error('put: Data must have an id field');
-            return false;
+            data.id = this.generateId();
         }
 
-        // Strict validation of schema and data
         const schema = await this.getSchema(lens);
         if (schema) {
-            try {
-                const valid = this.validator.validate(schema, data);
-                if (!valid) {
-                    const errors = this.validator.errors;
-                    console.error('put: Schema validation failed:', errors);
-                    return false;
-                }
-            } catch (error) {
-                console.error('put: Schema validation error:', error);
-                return false;
+            // Clone data to avoid modifying original
+            const dataToValidate = JSON.parse(JSON.stringify(data));
+            
+            // Validate against schema
+            const valid = this.validator.validate(schema, dataToValidate);
+            if (!valid) {
+                throw new Error(`Schema validation failed: ${JSON.stringify(this.validator.errors)}`);
             }
         } else if (this.strict) {
-            console.error('put: Schema required in strict mode for lens:', lens);
-            return false;
+            throw new Error('Schema required in strict mode');
         }
 
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             try {
                 const payload = JSON.stringify(data);
-                
                 this.gun.get(this.appname)
                     .get(holon)
                     .get(lens)
                     .get(data.id)
                     .put(payload, ack => {
                         if (ack.err) {
-                            console.error("Error adding data to GunDB:", ack.err);
-                            resolve(false);
+                            reject(new Error(ack.err));
                         } else {
                             resolve(true);
                         }
                     });
             } catch (error) {
-                console.error('Error in put operation:', error);
-                resolve(false);
+                reject(error);
             }
         });
     }
@@ -238,64 +211,110 @@ class HoloSphere {
      */
     async getAll(holon, lens) {
         if (!holon || !lens) {
-            console.error('getAll: Missing required parameters:', { holon, lens });
-            return [];
+            throw new Error('getAll: Missing required parameters');
         }
 
         const schema = await this.getSchema(lens);
         if (!schema && this.strict) {
-            console.error('getAll: Schema required in strict mode for lens:', lens);
-            return [];
+            throw new Error('getAll: Schema required in strict mode');
         }
 
         return new Promise((resolve) => {
-            let output = [];
-            let counter = 0;
-            
-            this.gun.get(this.appname).get(holon).get(lens).once((data, key) => {
-                if (!data) {
-                    resolve(output);
-                    return;
-                }
+            const output = new Set();
+            const promises = new Set();
+            let timeout;
 
-                const mapLength = Object.keys(data).length - 1;
-                
-                this.gun.get(this.appname).get(holon).get(lens).map().once(async (itemdata, key) => {
-                    counter += 1;
-                    if (itemdata) {
-                        try {
-                            const parsed = JSON.parse(itemdata);
-                            
-                            if (schema) {
-                                const valid = this.validator.validate(schema, parsed);
-                                if (valid) {
-                                    output.push(parsed);
-                                } else if (this.strict) {
-                                    console.warn('Invalid data removed:', key, this.validator.errors);
-                                    await this.delete(holon, lens, key);
-                                } else {
-                                    console.warn('Invalid data found:', key, this.validator.errors);
-                                    output.push(parsed);
-                                }
-                            } else {
-                                output.push(parsed);
-                            }
-                        } catch (error) {
-                            console.error('Error parsing data:', error);
-                            if (this.strict) {
+            const processData = async (itemdata, key) => {
+                if (itemdata) {
+                    try {
+                        const parsed = await this.parse(itemdata);
+                        if (schema) {
+                            const valid = this.validator.validate(schema, parsed);
+                            if (valid || !this.strict) {
+                                output.add(parsed);
+                            } else if (this.strict) {
                                 await this.delete(holon, lens, key);
                             }
+                        } else {
+                            output.add(parsed);
+                        }
+                    } catch (error) {
+                        console.error('Error parsing data:', error);
+                        if (this.strict) {
+                            await this.delete(holon, lens, key);
                         }
                     }
+                }
+            };
 
-                    if (counter === mapLength) {
-                        resolve(output);
-                    }
+            const listener = this.gun.get(this.appname)
+                .get(holon)
+                .get(lens)
+                .map()
+                .on(async (data, key) => {
+                    const promise = processData(data, key);
+                    promises.add(promise);
+                    promise.finally(() => promises.delete(promise));
+
+                    // Reset timeout on new data
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => {
+                        listener.off();
+                        Promise.all(promises).then(() => resolve(Array.from(output)));
+                    }, 1000); // Wait 1 second after last received data
                 });
-            });
         });
     }
 
+    /**
+   * Parses data from GunDB, handling various data formats and references.
+   * @param {*} data - The data to parse, could be a string, object, or GunDB reference.
+   * @returns {Promise<object>} - The parsed data.
+   */
+    async parse(rawData) {
+        if (!rawData) {
+            throw new Error('parse: No data provided');
+        }
+
+        try {
+            if (rawData.soul) {
+                const data = await this.getNodeRef(rawData.soul).once();
+                if (!data) {
+                    throw new Error('Referenced data not found');
+                }
+                return JSON.parse(data);
+            }
+
+            let parsedData = {};
+            if (typeof rawData === 'object' && rawData !== null) {
+                if (rawData._ && rawData._["#"]) {
+                    const pathParts = rawData._['#'].split('/');
+                    if (pathParts.length < 4) {
+                        throw new Error('Invalid reference format');
+                    }
+                    parsedData = await this.get(pathParts[1], pathParts[2], pathParts[3]);
+                    if (!parsedData) {
+                        throw new Error('Referenced data not found');
+                    }
+                } else if (rawData._ && rawData._['>']) {
+                    const nodeValue = Object.values(rawData).find(v => typeof v !== 'object' && v !== '_');
+                    if (!nodeValue) {
+                        throw new Error('Invalid node data');
+                    }
+                    parsedData = JSON.parse(nodeValue);
+                } else {
+                    parsedData = rawData;
+                }
+            } else {
+                parsedData = JSON.parse(rawData);
+            }
+
+            return parsedData;
+        } catch (error) {
+            throw new Error(`Parse error: ${error.message}`);
+        }
+    }
+
     /**
      * Retrieves a specific key from the specified holon and lens.
      * @param {string} holon - The holon identifier.
@@ -322,17 +341,17 @@ class HoloSphere {
                 .get(holon)
                 .get(lens)
                 .get(key)
-                .once((data) => {
+                .once((data,key) => {
                     clearTimeout(timeout);
-                    
+                   
                     if (!data) {
                         resolve(null);
                         return;
                     }
 
                     try {
-                        const parsed = JSON.parse(data);
-                        
+                        const parsed = this.parse(data);
+
                         // Validate against schema if one exists
                         if (schema) {
                             const valid = this.validator.validate(schema, parsed);
@@ -344,7 +363,6 @@ class HoloSphere {
                                 }
                             }
                         }
-                        
                         resolve(parsed);
                     } catch (error) {
                         console.error('Error parsing data:', error);
@@ -360,18 +378,30 @@ class HoloSphere {
      * @param {string} lens - The lens from which to delete the key.
      * @param {string} key - The specific key to delete.
      */
-    async delete (holon, lens, key) {
-            return new Promise((resolve, reject) => {
-                this.gun.get(this.appname).get(holon).get(lens).get(key).put(null, ack => {
-                    if (ack.err) {
-                        resolve(ack.err);
-                    } else {
-                        resolve(ack.ok);
-                    }
-                });
-            });
+    async delete(holon, lens, key) {
+        if (!holon || !lens || !key) {
+            throw new Error('delete: Missing required parameters');
         }
 
+        return new Promise((resolve, reject) => {
+            try {
+                this.gun.get(this.appname)
+                    .get(holon)
+                    .get(lens)
+                    .get(key)
+                    .put(null, ack => {
+                        if (ack.err) {
+                            reject(new Error(ack.err));
+                        } else {
+                            resolve(true);
+                        }
+                    });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
     /**
      * Deletes all keys from a given holon and lens.
      * @param {string} holon - The holon identifier.
@@ -386,7 +416,7 @@ class HoloSphere {
 
         return new Promise((resolve) => {
             let deletionPromises = [];
-            
+
             // First get all the data to find keys to delete
             this.gun.get(this.appname).get(holon).get(lens).once((data) => {
                 if (!data) {
@@ -396,7 +426,7 @@ class HoloSphere {
 
                 // Get all keys except Gun's metadata key '_'
                 const keys = Object.keys(data).filter(key => key !== '_');
-                
+
                 // Create deletion promises for each key
                 keys.forEach(key => {
                     deletionPromises.push(
@@ -417,7 +447,7 @@ class HoloSphere {
                     .catch(error => {
                         console.error('Error in deleteAll:', error);
                         resolve(false);
-                    });
+                });
             });
         });
     }
@@ -432,37 +462,69 @@ class HoloSphere {
      * @param {object} node - The node to store.
      */
     async putNode(holon, lens, node) {
-            this.gun.get(this.appname).get(holon).get(lens).put(node)
+        if (!holon || !lens || !node) {
+            throw new Error('putNode: Missing required parameters');
         }
 
+        return new Promise((resolve, reject) => {
+            try {
+                this.gun.get(this.appname)
+                    .get(holon)
+                    .get(lens)
+                    .put(node, ack => {
+                        if (ack.err) {
+                            reject(new Error(ack.err));
+                        } else {
+                            resolve(true);
+                        }
+                    });
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
     /**
-   * Retrieves a specific gun node from the specified holon and lens.
-   * @param {string} holon - The holon identifier.
-   * @param {string} lens - The lens identifier.
-   * @param {string} key - The specific key to retrieve.
+     * Retrieves a specific gun node from the specified holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens identifier.
+     * @param {string} key - The specific key to retrieve.
    * @returns {Promise<object|null>} - The retrieved node or null if not found.
-   */
-    async getNode(holon, lens, key) {
+     */
+    getNode(holon, lens, key) {
         if (!holon || !lens || !key) {
             console.error('getNode: Missing required parameters');
             return null;
         }
 
-        return new Promise((resolve) => {
-            let timeout = setTimeout(() => {
-                console.warn('getNode: Operation timed out');
-                resolve(null);
-            }, 5000);
-
-            this.gun.get(this.appname)
+        return this.gun.get(this.appname)
                 .get(holon)
                 .get(lens)
                 .get(key)
-                .once((data) => {
-                    clearTimeout(timeout);
-                    resolve(data || null);
-                });
+
+    }
+
+    getNodeRef(soul) {
+        if (typeof soul !== 'string' || !soul) {
+            throw new Error('getNodeRef: Invalid soul parameter');
+        }
+
+        const parts = soul.split('/').filter(part => {
+            if (!part.trim() || /[<>:"/\\|?*]/.test(part)) {
+                throw new Error('getNodeRef: Invalid path segment');
+            }
+            return part.trim();
         });
+
+        if (parts.length === 0) {
+            throw new Error('getNodeRef: Invalid soul format');
+        }
+
+        let ref = this.gun.get(this.appname);
+        parts.forEach(part => {
+            ref = ref.get(part);
+        });
+        return ref;
     }
 
     /**
@@ -474,19 +536,16 @@ class HoloSphere {
      */
     async deleteNode(holon, lens, key) {
         if (!holon || !lens || !key) {
-            console.error('deleteNode: Missing required parameters');
-            return false;
+            throw new Error('deleteNode: Missing required parameters');
         }
-
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.gun.get(this.appname)
                 .get(holon)
                 .get(lens)
                 .get(key)
                 .put(null, ack => {
                     if (ack.err) {
-                        console.error('deleteNode: Error deleting node:', ack.err);
-                        resolve(false);
+                        reject(new Error(ack.err));
                     } else {
                         resolve(true);
                     }
@@ -502,14 +561,12 @@ class HoloSphere {
      * @returns {Promise<void>}
      */
     async putGlobal(tableName, data) {
-
-            return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => {
+            try {
                 if (!tableName || !data) {
-                    reject(new Error('Table name and data are required'));
-                    return;
+                    throw new Error('Table name and data are required');
                 }
 
-
                 if (data.id) {
                     this.gun.get(this.appname).get(tableName).get(data.id).put(JSON.stringify(data), ack => {
                         if (ack.err) {
@@ -527,8 +584,11 @@ class HoloSphere {
                         }
                     });
                 }
-            });
-        }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
 
     /**
     * Retrieves a specific key from a global table.
@@ -537,21 +597,21 @@ class HoloSphere {
     * @returns {Promise<object|null>} - The parsed data for the key or null if not found.
     */
     async getGlobal(tableName, key) {
-            return new Promise((resolve) => {
-                this.gun.get(this.appname).get(tableName).get(key).once((data) => {
-                    if (!data) {
-                        resolve(null);
-                        return;
-                    }
-                    try {
-                        const parsed = this.parse(data);
-                        resolve(parsed);
-                    } catch (e) {
-                        resolve(null);
-                    }
-                });
+        return new Promise((resolve) => {
+            this.gun.get(this.appname).get(tableName).get(key).once((data) => {
+                if (!data) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const parsed = this.parse(data);
+                    resolve(parsed);
+                } catch (e) {
+                    resolve(null);
+                }
             });
-        }
+        });
+    }
 
 
 
@@ -560,31 +620,86 @@ class HoloSphere {
      * @param {string} tableName - The table name to retrieve data from.
      * @returns {Promise<object|null>} - The parsed data from the table or null if not found.
      */
-    async getAllGlobal(tableName) {
-            return new Promise(async (resolve, reject) => {
-                let output = []
-                let counter = 0
-                this.gun.get(tableName.toString()).once((data, key) => {
-                    if (data) {
-                        const maplenght = Object.keys(data).length - 1
-                        this.gun.get(tableName.toString()).map().once(async (itemdata, key) => {
-                            counter += 1
-                            if (itemdata) {
-                                let parsed = await this.parse(itemdata)
+    // async getAllGlobal(tableName) {
+    //     return new Promise(async (resolve, reject) => {
+    //         let output = []
+    //         let counter = 0
+    //         this.gun.get(this.appname).get(tableName.toString()).once((data, key) => {
+                     
+    //             counter += 1
+    //             if (itemdata) {
+    //                 let parsed = await this.parse(itemdata)
+    //                 output.push(parsed);
+    //                 console.log('getAllGlobal: parsed: ', parsed)
+    //             }
+
+    //             if (counter == maplenght) {
+    //                 resolve(output);
+                            
+    //             }
+    //         }
+    //         );
+    //     }
+    //     )
+    // }
+    async getAllGlobal(lens) {
+        if ( !lens) {
+            console.error('getAll: Missing required parameters:', { lens });
+            return [];
+        }
+
+        const schema = await this.getSchema(lens);
+        if (!schema && this.strict) {
+            console.error('getAll: Schema required in strict mode for lens:', lens);
+            return [];
+        }
+
+        return new Promise((resolve) => {
+            let output = [];
+            let counter = 0;
+
+            this.gun.get(this.appname).get(lens).once((data, key) => {
+                if (!data) {
+                    resolve(output);
+                    return;
+                }
+
+                const mapLength = Object.keys(data).length - 1;
+
+                this.gun.get(this.appname).get(lens).map().once(async (itemdata, key) => {
+                    counter += 1;
+                    if (itemdata) {
+                        try {
+                            const parsed = await this.parse(itemdata);
+                            if (schema) {
+                                const valid = this.validator.validate(schema, parsed);
+                                if (valid) {
+                                    output.push(parsed);
+                                } else if (this.strict) {
+                                    console.warn('Invalid data removed:', key, this.validator.errors);
+                                    await this.delete(holon, lens, key);
+                                } else {
+                                    console.warn('Invalid data found:', key, this.validator.errors);
+                                    output.push(parsed);
+                                }
+                            } else {
                                 output.push(parsed);
                             }
-
-                            if (counter == maplenght) {
-                                resolve(output);
+                        } catch (error) {
+                            console.error('Error parsing data:', error);
+                            if (this.strict) {
+                                await this.delete(holon, lens, key);
                             }
                         }
-                        );
-                    } else resolve(output)
-                })
-            }
-            )
-        }
+                    }
 
+                    if (counter === mapLength) {
+                        resolve(output);
+                    }
+                });
+            });
+        });
+    }
     /**
      * Deletes a specific key from a global table.
      * @param {string} tableName - The table name to delete from.
@@ -592,8 +707,8 @@ class HoloSphere {
      * @returns {Promise<void>}
      */
     async deleteGlobal(tableName, key) {
-            await this.gun.get(this.appname).get(tableName).get(key).put(null)
-        }
+        await this.gun.get(this.appname).get(tableName).get(key).put(null)
+    }
 
     /**
      * Deletes an entire global table.
@@ -601,16 +716,17 @@ class HoloSphere {
      * @returns {Promise<void>}
      */
     async deleteAllGlobal(tableName) {
-
-            return new Promise((resolve) => {
-                this.gun.get(this.appname).get(tableName).map().put(null).once(
-                    (data, key) => this.gun.get(this.appname).get(tableName).get(key).put(null)
-                )
-                this.gun.get(this.appname).get(tableName).put({}, ack => {
-                    resolve();
-                });
-            });
-        }
+       // return new Promise((resolve) => {
+            this.gun.get(this.appname).get(tableName).map().once( (data, key)=> {
+            this.gun.get(this.appname).get(tableName).get(key).put(null)
+        })
+        this.gun.get(this.appname).get(tableName).put(null, ack => {
+            console.log('deleteAllGlobal: ack: ', ack)
+        })
+            //    resolve();
+            //});
+        // });
+    }
 
     // ================================ COMPUTE FUNCTIONS ================================
     /**
@@ -619,43 +735,58 @@ class HoloSphere {
      * @param {string} lens - The lens to compute.
      * @param {string} operation - The operation to perform.
      */
-    async compute(holon, lens, operation) {
-
-            let res = h3.getResolution(holon);
-            if(res < 1 || res > 15) return;
-        console.log(res)
-        let parent = h3.cellToParent(holon, res - 1);
-        let siblings = h3.cellToChildren(parent, res);
-        console.log(holon, parent, siblings, res)
-
-        let content = [];
-        let promises = [];
-
-        for (let i = 0; i < siblings.length; i++) {
-            promises.push(new Promise((resolve) => {
-                let timeout = setTimeout(() => {
-                    console.log(`Timeout for sibling ${i}`);
-                    resolve(); // Resolve the promise to prevent it from hanging
-                }, 1000); // Timeout of 5 seconds
-
-                this.gun.get(this.appname).get(siblings[i]).get(lens).map().once((data, key) => {
-                    clearTimeout(timeout); // Clear the timeout if data is received
-                    if (data) {
-                        content.push(data.content);
-                    }
-                    resolve(); // Resolve after processing data
-                });
-            }));
+    async compute(holon, lens, operation, depth = 0, maxDepth = 15) {
+        if (!holon || !lens) {
+            throw new Error('compute: Missing required parameters');
         }
 
+        if (depth >= maxDepth) return;
+
+        const res = h3.getResolution(holon);
+        if (res < 1 || res > 15) {
+            throw new Error('compute: Invalid holon resolution');
+        }
+
+        const parent = h3.cellToParent(holon, res - 1);
+        const siblings = h3.cellToChildren(parent, res);
+
+        const content = [];
+        const promises = siblings.map(sibling => 
+            new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    console.warn(`Timeout for sibling ${sibling}`);
+                    resolve();
+                }, 1000);
+
+                this.gun.get(this.appname)
+                    .get(sibling)
+                    .get(lens)
+                    .map()
+                    .once((data) => {
+                        clearTimeout(timeout);
+                        if (data?.content) {
+                            content.push(data.content);
+                        }
+                        resolve();
+                    });
+            })
+        );
+
         await Promise.all(promises);
-        console.log('Content:', content);
-        let computed = await this.summarize(content.join('\n'))
-        console.log('Computed:', computed)
-        let node = await this.gun.get(this.appname).get(parent + '_summary').put({ id: parent + '_summary', content: computed })
 
-        this.put(parent, lens, node);
-        this.compute(parent, lens, operation)
+        if (content.length > 0) {
+            const computed = await this.summarize(content.join('\n'));
+            const summaryId = `${parent}_summary`;
+            await this.put(parent, lens, { 
+                id: summaryId, 
+                content: computed,
+                timestamp: Date.now()
+            });
+
+            if (res > 1) { // Only recurse if not at top level
+                await this.compute(parent, lens, operation, depth + 1, maxDepth);
+            }
+        }
     }
 
     /**
@@ -664,14 +795,51 @@ class HoloSphere {
      * @param {string} lens - The lens to clear.
      */
     async clearlens(holon, lens) {
-        let entities = {};
+        if (!holon || !lens) {
+            throw new Error('clearlens: Missing required parameters');
+        }
 
-        // Get list out of Gun
-        this.gun.get(this.appname).get(holon).get(lens).map().once((data, key) => {
-            //entities = data;
-            //const id = Object.keys(entities)[0] // since this would be in object form, you can manipulate it as you would like. 
-            this.gun.get(this.appname).get(holon).get(lens).put({ [key]: null })
-        })
+        return new Promise((resolve, reject) => {
+            try {
+                const deletions = new Set();
+                const timeout = setTimeout(() => {
+                    if (deletions.size === 0) {
+                        resolve(); // No data to delete
+                    }
+                }, 1000);
+
+                this.gun.get(this.appname)
+                    .get(holon)
+                    .get(lens)
+                    .map()
+                    .once((data, key) => {
+                        if (data) {
+                            const deletion = new Promise((resolveDelete) => {
+                                this.gun.get(this.appname)
+                                    .get(holon)
+                                    .get(lens)
+                                    .get(key)
+                                    .put(null, ack => {
+                                        if (ack.err) {
+                                            console.error(`Failed to delete ${key}:`, ack.err);
+                                        }
+                                        resolveDelete();
+                                    });
+                            });
+                            deletions.add(deletion);
+                            deletion.finally(() => {
+                                deletions.delete(deletion);
+                                if (deletions.size === 0) {
+                                    clearTimeout(timeout);
+                                    resolve();
+                                }
+                            });
+                        }
+                    });
+            } catch (error) {
+                reject(error);
+            }
+        });
     }
 
 
@@ -722,12 +890,12 @@ class HoloSphere {
     async upcast(holon, lens, content) {
         let res = h3.getResolution(holon)
         if (res == 0) {
-            await this.putNode(holon, lens, content)
+            await this.put(holon, lens, content)
             return content
         }
         else {
             console.log('Upcasting ', holon, lens, content, res)
-            await this.putNode(holon, lens, content)
+            await this.put(holon, lens, content)
             let parent = h3.cellToParent(holon, res - 1)
             return this.upcast(parent, lens, content)
         }
@@ -802,10 +970,32 @@ class HoloSphere {
      * @param {string} lens - The lens to subscribe to.
      * @param {function} callback - The callback to execute on changes.
      */
-    subscribe(holon, lens, callback) {
-        this.gun.get(this.appname).get(holon).get(lens).map().on((data, key) => {
-            callback(data, key)
-        })
+    async subscribe(holon, lens, callback) {
+        const subscriptionId = `${holon}:${lens}:${Date.now()}`;
+        const listener = this.gun.get(this.appname).get(holon).get(lens).map().on(async (data, key) => {
+            if (data) callback(await this.parse(data), key);
+        });
+
+        this.subscriptions.set(subscriptionId, listener);
+
+        return {
+            unsubscribe: () => {
+                listener.off();
+                this.subscriptions.delete(subscriptionId);
+            },
+            id: subscriptionId
+        };
+    }
+
+    // Add cleanup method
+    cleanup() {
+        this.subscriptions.forEach(listener => listener.off());
+        this.subscriptions.clear();
+    }
+
+    // Add ID generation method
+    generateId() {
+        return Date.now().toString(36) + Math.random().toString(36).substr(2);
     }
 }