holosphere 1.1.3 → 1.1.4

package/holosphere.js

@@ -1,7 +1,7 @@
 import * as h3 from 'h3-js';
 import OpenAI from 'openai';
 import Gun from 'gun'
-import 'gun/sea' // Import SEA module
+import SEA from 'gun/sea.js'
 import Ajv2019 from 'ajv/dist/2019.js'
 
 
@@ -21,7 +21,7 @@ class HoloSphere {
             strict: false,  // Keep this false to avoid Ajv strict mode issues
             validateSchema: true // Always validate schemas
         });
-        
+
         // Use provided Gun instance or create new one
         this.gun = gunInstance || Gun({
             peers: ['https://gun.holons.io/gun', 'https://59.src.eco/gun'],
@@ -32,7 +32,7 @@ class HoloSphere {
         });
 
         // Initialize SEA
-        this.sea = Gun.SEA;
+        this.sea = SEA;
 
         if (openaikey != null) {
             this.openai = new OpenAI({
@@ -42,6 +42,9 @@ class HoloSphere {
 
         // Add currentSpace property to track logged in space
         this.currentSpace = null;
+
+        // Initialize subscriptions
+        this.subscriptions = {};
     }
 
     // ================================ SCHEMA FUNCTIONS ================================
@@ -108,7 +111,7 @@ class HoloSphere {
                     // Only set owner if there's an authenticated space
                     ...(this.currentSpace && { owner: this.currentSpace.alias })
                 };
-                
+
                 this.gun.get(this.appname)
                     .get(lens)
                     .get('schema')
@@ -159,7 +162,7 @@ class HoloSphere {
                             resolve(JSON.parse(data.schema));
                         } else {
                             // Legacy format or direct string
-                            const schemaStr = typeof data === 'string' ? data : 
+                            const schemaStr = typeof data === 'string' ? data :
                                 Object.values(data).find(v => typeof v === 'string' && v.includes('"type":'));
                             resolve(schemaStr ? JSON.parse(schemaStr) : null);
                         }
@@ -190,8 +193,8 @@ class HoloSphere {
         // If updating existing data, check ownership
         if (data.id) {
             const existing = await this.get(holon, lens, data.id);
-            if (existing && existing.owner && 
-                existing.owner !== this.currentSpace.alias && 
+            if (existing && existing.owner &&
+                existing.owner !== this.currentSpace.alias &&
                 !existing.federation) { // Skip ownership check for federated data
                 throw new Error('Unauthorized to modify this data');
             }
@@ -221,7 +224,7 @@ class HoloSphere {
             // Deep clone data to avoid modifying the original
             const dataToValidate = JSON.parse(JSON.stringify(dataWithMeta));
             const valid = this.validator.validate(schema, dataToValidate);
-            
+
             if (!valid) {
                 const errorMsg = `Schema validation failed: ${JSON.stringify(this.validator.errors)}`;
                 // Always throw on schema validation failure, regardless of strict mode
@@ -243,6 +246,12 @@ class HoloSphere {
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
+                            // Notify subscribers after successful put
+                            this.notifySubscribers({
+                                holon,
+                                lens,
+                                ...dataWithMeta
+                            });
                             resolve(true);
                         }
                     });
@@ -275,7 +284,7 @@ class HoloSphere {
             }
 
             // Propagate to each federated space
-            const propagationPromises = fedInfo.notify.map(spaceId => 
+            const propagationPromises = fedInfo.notify.map(spaceId =>
                 new Promise((resolve) => {
                     // Store data in the federated space's lens
                     this.gun.get(this.appname)
@@ -335,7 +344,7 @@ class HoloSphere {
 
         // Get local data
         const localData = await this._getAllLocal(holon, lens, schema);
-        
+
         // If authenticated, get federated data
         let federatedData = [];
         if (this.currentSpace) {
@@ -344,7 +353,7 @@ class HoloSphere {
 
         // Combine and deduplicate data based on ID
         const combined = new Map();
-        
+
         // Add local data first
         localData.forEach(item => {
             if (item.id) {
@@ -356,7 +365,7 @@ class HoloSphere {
         federatedData.forEach(item => {
             if (item.id) {
                 const existing = combined.get(item.id);
-                if (!existing || 
+                if (!existing ||
                     (item.federation?.timestamp > (existing.federation?.timestamp || 0))) {
                     combined.set(item.id, item);
                 }
@@ -426,7 +435,7 @@ class HoloSphere {
             const output = new Map();
             let isResolved = false;
             let listener = null;
-            
+
             const hardTimeout = setTimeout(() => {
                 cleanup();
                 resolve(Array.from(output.values()));
@@ -505,7 +514,7 @@ class HoloSphere {
             }
 
             const federatedData = new Map();
-            
+
             // Get data from each federated space
             const fedPromises = fedInfo.federation.map(spaceId =>
                 new Promise((resolve) => {
@@ -632,7 +641,7 @@ class HoloSphere {
                 .get(key)
                 .once(async (data) => {
                     clearTimeout(timeout);
-                   
+
                     if (!data) {
                         resolve(null);
                         return;
@@ -658,7 +667,7 @@ class HoloSphere {
                         // 2. User is the owner
                         // 3. User is in shared list
                         // 4. Data is from federation
-                        if (parsed.owner && 
+                        if (parsed.owner &&
                             this.currentSpace?.alias !== parsed.owner &&
                             (!parsed.shared || !parsed.shared.includes(this.currentSpace?.alias)) &&
                             (!parsed.federation || !parsed.federation.origin)) {
@@ -711,7 +720,7 @@ class HoloSphere {
         if (!data) {
             return true; // Nothing to delete
         }
-        
+
         if (data.owner && data.owner !== this.currentSpace.alias) {
             throw new Error('Unauthorized to delete this data');
         }
@@ -780,7 +789,7 @@ class HoloSphere {
                     .catch(error => {
                         console.error('Error in deleteAll:', error);
                         resolve(false);
-                });
+                    });
             });
         });
     }
@@ -985,12 +994,12 @@ class HoloSphere {
                 }
 
                 const keys = Object.keys(data).filter(key => key !== '_');
-                const promises = keys.map(key => 
+                const promises = keys.map(key =>
                     new Promise(async (resolveItem) => {
                         const itemData = await new Promise(resolveData => {
                             this.gun.get(this.appname).get(tableName).get(key).once(resolveData);
                         });
-                        
+
                         if (itemData) {
                             try {
                                 const parsed = await this.parse(itemData);
@@ -1088,7 +1097,7 @@ class HoloSphere {
                     }
 
                     const keys = Object.keys(data).filter(key => key !== '_');
-                    const promises = keys.map(key => 
+                    const promises = keys.map(key =>
                         new Promise((resolveDelete) => {
                             this.gun.get(this.appname)
                                 .get(tableName)
@@ -1120,21 +1129,62 @@ class HoloSphere {
 
     // ================================ COMPUTE FUNCTIONS ================================
     /**
-     * Computes summaries based on the content within a holon and lens.
+   
+   /**
+ * Computes operations across multiple layers up the hierarchy
+ * @param {string} holon - Starting holon identifier
+ * @param {string} lens - The lens to compute
+ * @param {object} options - Computation options
+ * @param {number} [maxLevels=15] - Maximum levels to compute up
+ */
+    async computeHierarchy(holon, lens, options, maxLevels = 15) {
+        let currentHolon = holon;
+        let currentRes = h3.getResolution(currentHolon);
+        const results = [];
+
+        while (currentRes > 0 && maxLevels > 0) {
+            try {
+                const result = await this.compute(currentHolon, lens, options);
+                if (result) {
+                    results.push(result);
+                }
+                currentHolon = h3.cellToParent(currentHolon, currentRes - 1);
+                currentRes--;
+                maxLevels--;
+            } catch (error) {
+                console.error('Error in compute hierarchy:', error);
+                break;
+            }
+        }
+
+        return results;
+    }
+
+    /* Computes operations on content within a holon and lens for one layer up.
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens to compute.
-     * @param {string} operation - The operation to perform.
-     * @param {number} [depth=0] - Current recursion depth.
-     * @param {number} [maxDepth=15] - Maximum recursion depth.
+     * @param {object} options - Computation options
+     * @param {string} options.operation - The operation to perform ('summarize', 'aggregate', 'concatenate')
+     * @param {string[]} [options.fields] - Fields to perform operation on
+     * @param {string} [options.targetField] - Field to store the result in
      * @throws {Error} If parameters are invalid or missing
      */
-    async compute(holon, lens, operation, depth = 0, maxDepth = 15) {
+    async compute(holon, lens, options) {
         // Validate required parameters
-        if (!holon || !lens || !operation) {
+        if (!holon || !lens) {
+            throw new Error('compute: Missing required parameters');
+        }
+
+        // Convert string operation to options object
+        if (typeof options === 'string') {
+            options = { operation: options };
+        }
+
+        if (!options?.operation) {
             throw new Error('compute: Missing required parameters');
         }
 
-        // Validate holon format and resolution
+        // Validate holon format and resolution first
         let res;
         try {
             res = h3.getResolution(holon);
@@ -1146,141 +1196,108 @@ class HoloSphere {
             throw new Error('compute: Invalid holon resolution (must be between 1 and 15)');
         }
 
-        // Validate depth parameters
-        if (typeof depth !== 'number' || depth < 0) {
+        const {
+            operation,
+            fields = [],
+            targetField,
+            depth,
+            maxDepth
+        } = options;
+
+        // Validate depth parameters if provided
+        if (depth !== undefined && depth < 0) {
             throw new Error('compute: Invalid depth parameter');
         }
 
-        if (typeof maxDepth !== 'number' || maxDepth < 1 || maxDepth > 15) {
+        if (maxDepth !== undefined && (maxDepth < 1 || maxDepth > 15)) {
             throw new Error('compute: Invalid maxDepth parameter (must be between 1 and 15)');
         }
 
-        if (depth >= maxDepth) {
-            return;
-        }
-
         // Validate operation
-        if (typeof operation !== 'string' || !['summarize'].includes(operation)) {
-            throw new Error('compute: Invalid operation (must be "summarize")');
+        const validOperations = ['summarize', 'aggregate', 'concatenate'];
+        if (!validOperations.includes(operation)) {
+            throw new Error(`compute: Invalid operation (must be one of ${validOperations.join(', ')})`);
         }
 
         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();
-                }, 10000);
-
-                this.gun.get(this.appname)
-                    .get(sibling)
-                    .get(lens)
-                    .map()
-                    .once((data) => {
-                        clearTimeout(timeout);
-                        if (!data) {
-                            resolve();
-                            return;
-                        }
-
-                        try {
-                            // Parse the data if it's a string
-                            const parsed = typeof data === 'string' ? JSON.parse(data) : data;
-                            if (parsed && parsed.content) {
-                                content.push(parsed.content);
-                            }
-                        } catch (error) {
-                            console.warn('Error parsing data:', error);
-                        }
-                        resolve();
-                    });
-            })
+        // Collect all content from siblings
+        const contents = await Promise.all(
+            siblings.map(sibling => this.getAll(sibling, lens))
         );
 
-        await Promise.all(promises);
+        const flatContents = contents.flat().filter(Boolean);
 
-        if (content.length > 0) {
+        if (flatContents.length > 0) {
             try {
-                const computed = await this.summarize(content.join('\n'));
+                let computed;
+                switch (operation) {
+                    case 'summarize':
+                        // For summarize, concatenate specified fields or use entire content
+                        const textToSummarize = fields.length > 0
+                            ? flatContents.map(item => fields.map(field => item[field]).filter(Boolean).join('\n')).join('\n')
+                            : JSON.stringify(flatContents);
+                        computed = await this.summarize(textToSummarize);
+                        break;
+
+                    case 'aggregate':
+                        // For aggregate, sum numeric fields
+                        computed = fields.reduce((acc, field) => {
+                            acc[field] = flatContents.reduce((sum, item) => {
+                                return sum + (Number(item[field]) || 0);
+                            }, 0);
+                            return acc;
+                        }, {});
+                        break;
+
+                    case 'concatenate':
+                        // For concatenate, combine arrays or strings
+                        computed = fields.reduce((acc, field) => {
+                            acc[field] = flatContents.reduce((combined, item) => {
+                                const value = item[field];
+                                if (Array.isArray(value)) {
+                                    return [...combined, ...value];
+                                } else if (value) {
+                                    return [...combined, value];
+                                }
+                                return combined;
+                            }, []);
+                            // Remove duplicates if array
+                            acc[field] = Array.from(new Set(acc[field]));
+                            return acc;
+                        }, {});
+                        break;
+                }
+
                 if (computed) {
-                    const summaryId = `${parent}_summary`;
-                    await this.put(parent, lens, { 
-                        id: summaryId, 
-                        content: computed,
+                    const resultId = `${parent}_${operation}`;
+                    const result = {
+                        id: resultId,
                         timestamp: Date.now()
-                    });
+                    };
 
-                    if (res > 1) { // Only recurse if not at top level
-                        await this.compute(parent, lens, operation, depth + 1, maxDepth);
+                    // Store result in targetField if specified, otherwise at root level
+                    if (targetField) {
+                        result[targetField] = computed;
+                    } else if (typeof computed === 'object') {
+                        Object.assign(result, computed);
+                    } else {
+                        result.value = computed;
                     }
+
+                    await this.put(parent, lens, result);
+                    return result;
                 }
             } catch (error) {
                 console.warn('Error in compute operation:', error);
-                // Don't throw here to maintain graceful handling of compute errors
+                throw error;
             }
         }
 
-        // Return successfully even if no content was found or processed
-        return;
-    }
-
-    /**
-     * Clears all entities under a specific holon and lens.
-     * @param {string} holon - The holon identifier.
-     * @param {string} lens - The lens to clear.
-     */
-    async clearlens(holon, lens) {
-        if (!holon || !lens) {
-            throw new Error('clearlens: Missing required parameters');
-        }
-
-        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);
-            }
-        });
+        return null;
     }
 
-
     /**
      * Summarizes provided history text using OpenAI.
      * @param {string} history - The history text to summarize.
@@ -1406,47 +1423,46 @@ class HoloSphere {
      * @param {function} callback - The callback to execute on changes.
      */
     async subscribe(holon, lens, callback) {
-        if (!holon || !lens || !callback) {
-            throw new Error('subscribe: Missing required parameters');
-        }
-
-        const ref = this.gun.get(this.appname)
-            .get(holon)
-            .get(lens);
-
-        // Create a more robust handler
-        const handler = async (data, key) => {
-            if (!data || key === '_') return; // Skip empty data or Gun metadata
-
-            try {
-                const parsed = typeof data === 'string' ? await this.parse(data) : data;
-                if (parsed) {
-                    await callback(parsed);
-                }
-            } catch (error) {
-                console.warn('Subscription handler error:', error);
-            }
+        const subscriptionId = this.generateSubscriptionId();
+        this.subscriptions[subscriptionId] = {
+            query: { holon, lens },
+            callback,
+            active: true
         };
 
-        // Subscribe using Gun's map() and on()
-        const chain = ref.map();
-        chain.on(handler);
-
-        // Return subscription object
+        // Add cleanup to ensure callback isn't called after unsubscribe
         return {
-            off: () => {
-                if (chain) {
-                    chain.off();
+            unsubscribe: () => {
+                if (this.subscriptions[subscriptionId]) {
+                    delete this.subscriptions[subscriptionId];
                 }
             }
         };
     }
 
+    notifySubscribers(data) {
+        Object.values(this.subscriptions).forEach(subscription => {
+            if (subscription.active && this.matchesQuery(data, subscription.query)) {
+                subscription.callback(data);
+            }
+        });
+    }
+
     // Add ID generation method
     generateId() {
         return Date.now().toString(10) + Math.random().toString(2);
     }
 
+    generateSubscriptionId() {
+        return Date.now().toString(10) + Math.random().toString(2);
+    }
+
+    matchesQuery(data, query) {
+        return data && query && 
+               data.holon === query.holon && 
+               data.lens === query.lens;
+    }
+
     /**
      * Creates a new space with the given credentials
      * @param {string} spacename - The space identifier/username
@@ -1467,7 +1483,7 @@ class HoloSphere {
         try {
             // Generate key pair
             const pair = await Gun.SEA.pair();
-            
+
             // Create auth record with SEA
             const salt = await Gun.SEA.random(64).toString('base64');
             const hash = await Gun.SEA.work(password, salt);
@@ -1505,8 +1521,8 @@ class HoloSphere {
      */
     async login(spacename, password) {
         // Validate input
-        if (!spacename || !password || 
-            typeof spacename !== 'string' || 
+        if (!spacename || !password ||
+            typeof spacename !== 'string' ||
             typeof password !== 'string') {
             throw new Error('Invalid credentials format');
         }
@@ -1738,10 +1754,10 @@ class HoloSphere {
 
         // Get federation info for current space
         const fedInfo = await this.getFederation(this.currentSpace?.alias);
-        
+
         // Get local data
         const localData = await this.getAll(holon, lens);
-        
+
         // If no federation or not authenticated, return local data only
         if (!fedInfo || !fedInfo.federation || fedInfo.federation.length === 0) {
             return localData;
@@ -1828,15 +1844,15 @@ class HoloSphere {
         if (!removeDuplicates) {
             return allData;
         }
-        
+
         // Remove duplicates keeping the most recent version
         const uniqueMap = new Map();
         allData.forEach(item => {
             const id = item[idField];
             if (!id) return;
-            
+
             const existing = uniqueMap.get(id);
-            if (!existing || 
+            if (!existing ||
                 (item.federation?.timestamp > (existing.federation?.timestamp || 0))) {
                 uniqueMap.set(id, item);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",
@@ -14,6 +14,7 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "ajv": "^8.12.0",
+    "dotenv": "^16.4.7",
     "gun": "^0.2020.1240",
     "h3-js": "^4.1.0",
     "openai": "^4.85.1"

package/test/ai.test.js

@@ -0,0 +1,233 @@
+import HoloSphere from '../holosphere.js';
+import * as h3 from 'h3-js';
+import { jest } from '@jest/globals';
+import 'dotenv/config';
+
+// Set global timeout for all tests
+jest.setTimeout(120000);
+
+describe('AI Operations', () => {
+    let holoSphere;
+    const testAppName = 'test-ai-app';
+    const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
+    const testLens = 'aiTestLens';
+    const testCredentials = {
+        spacename: 'aitest@example.com',
+        password: 'AiTest123!'
+    };
+
+    beforeAll(async () => {
+        holoSphere = new HoloSphere(testAppName, false, process.env.OPENAI_API_KEY);
+        
+        // Clean up any existing test space and data
+        try {
+            await holoSphere.deleteAllGlobal('federation');
+            await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
+        } catch (error) {
+            console.log('Cleanup error (can be ignored):', error);
+        }
+        // Create and login to test space
+        await holoSphere.createSpace(testCredentials.spacename, testCredentials.password);
+        await holoSphere.login(testCredentials.spacename, testCredentials.password);
+        // Set up base schema for compute tests
+        const baseSchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                content: { type: 'string' },
+                value: { type: 'number' },
+                tags: { type: 'array', items: { type: 'string' } },
+                timestamp: { type: 'number' }
+            },
+            required: ['id']
+        };
+        
+        await holoSphere.setSchema(testLens, baseSchema);
+    }, 30000);
+
+    describe('Summarize Operations', () => {
+        test('should generate summary from text content', async () => {
+            const testContent = `
+                The HoloSphere project is a decentralized data management system.
+                It uses Gun.js for peer-to-peer data synchronization and SEA for encryption.
+                The system supports federation between spaces and implements schema validation.
+                Data can be organized in holons and viewed through different lenses.
+            `;
+
+            const summary = await holoSphere.summarize(testContent);
+            console.log("summary",summary);
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+            expect(summary.length).toBeGreaterThan(0);
+        }, 15000);
+
+        test('should handle empty content gracefully', async () => {
+            const summary = await holoSphere.summarize('');
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+        }, 10000);
+
+        test('should handle long content', async () => {
+            const longContent = Array(10).fill(
+                'This is a long paragraph of text that needs to be summarized. ' +
+                'It contains multiple sentences with various information. ' +
+                'The summary should capture the key points while remaining concise.'
+            ).join('\n');
+
+            const summary = await holoSphere.summarize(longContent);
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+            expect(summary.length).toBeLessThan(longContent.length);
+        }, 20000);
+
+        test('should fail gracefully without API key', async () => {
+            const noKeyHoloSphere = new HoloSphere(testAppName, false);
+            const result = await noKeyHoloSphere.summarize('Test content');
+            expect(result).toBe('OpenAI not initialized, please specify the API key in the constructor.');
+        });
+    });
+
+    describe('Compute Operations', () => {
+        beforeEach(async () => {
+            // Ensure we're logged in
+            if (!holoSphere.currentSpace) {
+                await holoSphere.login(testCredentials.spacename, testCredentials.password);
+            }
+            
+            // Clean up any existing test data
+            await holoSphere.deleteAll(testHolon, testLens);
+        }, 15000);
+
+        test('should compute summaries for nested holons', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = {
+                id: 'test1',
+                content: 'This is test content for the child holon that should be summarized.',
+                timestamp: Date.now()
+            };
+
+            // Put data in child holon
+            await holoSphere.put(childHolon, testLens, testData);
+
+            // Compute summaries
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content'],
+                targetField: 'summary'
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_summarize$/);
+            expect(result.summary).toBeDefined();
+            expect(typeof result.summary).toBe('string');
+        }, 60000);
+
+        test('should compute aggregations for numeric fields', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = [
+                { id: 'test1', value: 10, timestamp: Date.now() },
+                { id: 'test2', value: 20, timestamp: Date.now() }
+            ];
+
+            // Put test data
+            await Promise.all(testData.map(data => holoSphere.put(childHolon, testLens, data)));
+
+            // Compute aggregation
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'aggregate',
+                fields: ['value']
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_aggregate$/);
+            expect(result.value).toBe(30);
+        }, 30000);
+
+        test('should compute concatenations for array fields', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = [
+                { id: 'test1', tags: ['tag1', 'tag2'], timestamp: Date.now() },
+                { id: 'test2', tags: ['tag2', 'tag3'], timestamp: Date.now() }
+            ];
+
+            // Put test data
+            await Promise.all(testData.map(data => holoSphere.put(childHolon, testLens, data)));
+
+            // Compute concatenation
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'concatenate',
+                fields: ['tags']
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_concatenate$/);
+            expect(result.tags).toEqual(['tag1', 'tag2', 'tag3']);
+        }, 30000);
+
+
+        test('should handle empty holons', async () => {
+            // Clean up any existing data first
+            await holoSphere.deleteAll(testHolon, testLens);
+       
+            // Try to compute on empty holon
+            const result = await holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content']
+            });
+    
+            expect(result).toBeNull();
+        }, 30000);
+
+        test('should compute hierarchy across multiple levels', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 9)[0];
+            const testData = {
+                id: 'test-hierarchy',
+                content: 'Content for testing hierarchy computation',
+                value: 42,
+                tags: ['test', 'hierarchy'],
+                timestamp: Date.now()
+            };
+
+            // Put test data
+            await holoSphere.put(childHolon, testLens, testData);
+      
+            // Compute hierarchy
+            const results = await holoSphere.computeHierarchy(childHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content'],
+                targetField: 'summary'
+            }, 3);
+         
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBeGreaterThan(0);
+            results.forEach(result => {
+                expect(result.id).toMatch(/_summarize$/);
+                expect(result.summary).toBeDefined();
+                expect(typeof result.summary).toBe('string');
+            });
+        }, 60000);
+    });
+
+    afterEach(async () => {
+        // Clean up test data
+        if (holoSphere.currentSpace) {
+            await holoSphere.deleteAll(testHolon, testLens);
+        }
+    }, 15000);
+
+    afterAll(async () => {
+        // Clean up test space and data
+        try {
+            await holoSphere.deleteAll(testHolon, testLens);
+            await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
+            await holoSphere.deleteAllGlobal('federation');
+        } catch (error) {
+            console.log('Cleanup error (can be ignored):', error);
+        }
+
+        // Clean up Gun instance
+        if (holoSphere.gun) {
+            holoSphere.gun.off();
+        }
+    }, 30000);
+}); 

package/test/federation.test.js

@@ -1,9 +1,8 @@
 import HoloSphere from '../holosphere.js';
-import * as h3 from 'h3-js';
 import { jest } from '@jest/globals';
 
 // Set global timeout for all tests
-jest.setTimeout(30000);
+jest.setTimeout(3000);
 
 describe('Federation Operations', () => {
     const testAppName = 'test-app';
@@ -28,8 +27,6 @@ describe('Federation Operations', () => {
             await holoSphere.deleteAllGlobal('federation');
             await holoSphere.deleteGlobal('spaces', space1.spacename);
             await holoSphere.deleteGlobal('spaces', space2.spacename);
-            // Wait for cleanup
-            await new Promise(resolve => setTimeout(resolve, 2000));
         } catch (error) {
             // Ignore errors during cleanup
             console.log('Cleanup error (expected):', error.message);
@@ -44,12 +41,9 @@ describe('Federation Operations', () => {
             } catch (error) {
                 console.log('Space creation attempt', i + 1, 'failed:', error.message);
                 if (i === 2) throw error;
-                await new Promise(resolve => setTimeout(resolve, 2000));
             }
         }
 
-        // Wait for space creation to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
 
         // Verify spaces were created
         const space1Created = await holoSphere.getGlobal('spaces', space1.spacename);
@@ -58,9 +52,6 @@ describe('Federation Operations', () => {
         if (!space1Created || !space2Created) {
             throw new Error('Failed to create test spaces');
         }
-
-        // Wait for everything to settle
-        await new Promise(resolve => setTimeout(resolve, 2000));
     }, 30000);
 
     beforeEach(async () => {
@@ -91,9 +82,7 @@ describe('Federation Operations', () => {
         await holoSphere.setSchema(testLens, baseSchema);
         await strictHoloSphere.setSchema(testLens, baseSchema);
         
-        // Wait for schema to be set
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        
+    
         // Verify spaces exist before proceeding
         const space1Exists = await holoSphere.getGlobal('spaces', space1.spacename);
         const space2Exists = await holoSphere.getGlobal('spaces', space2.spacename);
@@ -102,7 +91,6 @@ describe('Federation Operations', () => {
         if (!space1Exists) {
             try {
                 await holoSphere.createSpace(space1.spacename, space1.password);
-                await new Promise(resolve => setTimeout(resolve, 2000));
             } catch (error) {
                 if (error.message !== 'Space already exists') {
                     throw error;
@@ -112,7 +100,6 @@ describe('Federation Operations', () => {
         if (!space2Exists) {
             try {
                 await holoSphere.createSpace(space2.spacename, space2.password);
-                await new Promise(resolve => setTimeout(resolve, 2000));
             } catch (error) {
                 if (error.message !== 'Space already exists') {
                     throw error;
@@ -120,9 +107,6 @@ describe('Federation Operations', () => {
             }
         }
         
-        // Wait for space creation to complete
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        
         // Verify spaces again
         const space1Verified = await holoSphere.getGlobal('spaces', space1.spacename);
         const space2Verified = await holoSphere.getGlobal('spaces', space2.spacename);
@@ -142,17 +126,12 @@ describe('Federation Operations', () => {
         // Login as first space to holoSphere
         await holoSphere.login(space1.spacename, space1.password);
         
-        // Wait for login to complete
-        await new Promise(resolve => setTimeout(resolve, 2000));
     }, 20000);
 
     test('should create federation relationship between spaces', async () => {
         // Create federation relationship
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
         // Verify federation was created
         const fedInfo = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo).toBeDefined();
@@ -163,9 +142,6 @@ describe('Federation Operations', () => {
         // Create bidirectional federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 2000));
-
         // Login to space1 to verify federation
         await holoSphere.login(space1.spacename, space1.password);
 
@@ -186,9 +162,6 @@ describe('Federation Operations', () => {
         // Create initial federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 3000));
-
         // Verify federation exists
         const fedInfo = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo).toBeDefined();
@@ -213,18 +186,12 @@ describe('Federation Operations', () => {
         // Set up federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Login to space2 with strict instance
         await strictHoloSphere.login(space2.spacename, space2.password);
 
         // Put data in first space
         await holoSphere.put(testHolon, testLens, testData);
 
-        // Wait for propagation
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify data was propagated to federated space
         const federatedData = await strictHoloSphere.get(testHolon, testLens, testData.id);
         expect(federatedData).toBeDefined();
@@ -239,9 +206,6 @@ describe('Federation Operations', () => {
         // Clean up any existing test data first
         await holoSphere.deleteAll(testHolon, testLens);
         await strictHoloSphere.deleteAll(testHolon, testLens);
-        
-        // Wait for cleanup to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
 
         // Set up federation using non-strict instance (already logged in as space1)
         await holoSphere.federate(space1.spacename, space2.spacename);
@@ -249,9 +213,6 @@ describe('Federation Operations', () => {
         // Login to space2 with strict instance
         await strictHoloSphere.login(space2.spacename, space2.password);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Test data with overlapping IDs and different fields
         const testData1 = { 
             id: 'user1', 
@@ -281,18 +242,13 @@ describe('Federation Operations', () => {
         // Put data using both instances and wait between puts
         console.log('Putting test data 1:', JSON.stringify(testData1, null, 2));
         await holoSphere.put(testHolon, testLens, testData1);
-        await new Promise(resolve => setTimeout(resolve, 5000));
         
         console.log('Putting test data 2:', JSON.stringify(testData2, null, 2));
         await strictHoloSphere.put(testHolon, testLens, testData2);
-        await new Promise(resolve => setTimeout(resolve, 5000));
         
         console.log('Putting test data 3:', JSON.stringify(testData3, null, 2));
         await holoSphere.put(testHolon, testLens, testData3);
 
-        // Wait longer for data propagation
-        await new Promise(resolve => setTimeout(resolve, 10000));
-
         // Test 1: Simple concatenation without deduplication
         const concatenatedResults = await holoSphere.getFederated(testHolon, testLens, {
             aggregate: false,
@@ -352,9 +308,6 @@ describe('Federation Operations', () => {
         // Set up federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify federation exists
         let fedInfo1 = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo1).toBeDefined();
@@ -364,9 +317,6 @@ describe('Federation Operations', () => {
         // Remove federation
         await holoSphere.unfederate(space1.spacename, space2.spacename);
 
-        // Wait for unfederation to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify federation is removed
         fedInfo1 = await holoSphere.getFederation(space1.spacename);
         const fedInfo2 = await holoSphere.getFederation(space2.spacename);
@@ -391,9 +341,6 @@ describe('Federation Operations', () => {
         if (strictHoloSphere.currentSpace) {
             await strictHoloSphere.logout();
         }
-        
-        // Wait for cleanup
-        await new Promise(resolve => setTimeout(resolve, 1000));
     });
 
     afterAll(async () => {
@@ -401,8 +348,6 @@ describe('Federation Operations', () => {
         try {
             await holoSphere.deleteGlobal('spaces', space1.spacename);
             await holoSphere.deleteGlobal('spaces', space2.spacename);
-            // Wait for cleanup
-            await new Promise(resolve => setTimeout(resolve, 1000));
         } catch (error) {
             console.error('Error during final cleanup:', error.message);
         }

package/test/holosphere.test.js

@@ -152,8 +152,6 @@ describe('HoloSphere', () => {
                 // Store schema
                 await strictHoloSphere.setSchema(testLensWithIndex, schema);
                 
-                // Add delay to ensure schema is stored
-                await new Promise(resolve => setTimeout(resolve, 100));
 
                 // Retrieve schema
                 const retrievedSchema = await strictHoloSphere.getSchema(testLensWithIndex);
@@ -198,7 +196,6 @@ describe('HoloSphere', () => {
             // Clean up the strict instance
             if (strictHoloSphere.gun) {
                 await strictHoloSphere.logout();
-                await new Promise(resolve => setTimeout(resolve, 100)); // Allow time for cleanup
             }
         }, 10000); // Increase timeout to 10 seconds
 
@@ -220,16 +217,12 @@ describe('HoloSphere', () => {
                     required: ['id', 'value']
                 };
                 expectedSchemas.push({ lens, schema });
-                // Add small delay between operations to prevent race conditions
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.setSchema(lens, schema));
             }
 
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 500));
 
             // Verify each schema was stored correctly
             for (const { lens, schema } of expectedSchemas) {
@@ -480,9 +473,6 @@ describe('HoloSphere', () => {
                 await holoSphere.put(testHolon, testLens, storeData);
             }
 
-            // Wait a bit to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 100));
-
             // Get data multiple times
             const results = await Promise.all(
                 Array.from({ length: 5 }, () => holoSphere.getAll(testHolon, testLens))
@@ -671,27 +661,33 @@ describe('HoloSphere', () => {
         test('should stop receiving data after unsubscribe', async () => {
             const testData1 = { id: 'test1', data: 'first' };
             const testData2 = { id: 'test2', data: 'second' };
-            let received = false;
+            let receivedData = [];
 
-            const subscription = await holoSphere.subscribe(testHolon, testLens, async (data) => {
-                if (!received && data.id === testData1.id) {
-                    received = true;
-                    await subscription.off();
-                    
-                    // Put second piece of data after unsubscribe
-                    await holoSphere.put(testHolon, testLens, testData2);
+            return new Promise(async (resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    // If we only received the first piece of data, test passes
+                    if (receivedData.length === 1 && receivedData[0].id === testData1.id) {
+                        resolve();
+                    } else {
+                        reject(new Error('Test timeout or received unexpected data'));
+                    }
+                }, 5000);
+
+                const subscription = await holoSphere.subscribe(testHolon, testLens, async (data) => {
+                    receivedData.push(data);
                     
-                    // Wait a bit to ensure no more data is received
-                    setTimeout(() => {
-                        expect(received).toBe(true);
-                    }, 1000);
-                } else if (data.id === testData2.id) {
-                    throw new Error('Received data after unsubscribe');
-                }
-            });
+                    if (data.id === testData1.id) {
+                        subscription.unsubscribe();
+                        resolve();
+                    } else if (data.id === testData2.id) {
+                        clearTimeout(timeout);
+                        reject(new Error('Received data after unsubscribe'));
+                    }
+                });
 
-            // Put first piece of data
-            await holoSphere.put(testHolon, testLens, testData1);
+                // Put first piece of data
+                await holoSphere.put(testHolon, testLens, testData1);
+            });
         }, 10000);
 
         test('should handle multiple subscriptions', async () => {
@@ -846,16 +842,13 @@ describe('HoloSphere', () => {
             for (let i = 0; i < numOperations; i++) {
                 const data = { id: `concurrent${i}`, value: `value${i}` };
                 expectedData.push(data);
-                // Add small delay between operations
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.putGlobal(testTable, data));
             }
 
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification
-            await new Promise(resolve => setTimeout(resolve, 500));
+
 
             // Retrieve and verify data
             const retrievedData = await holoSphere.getAllGlobal(testTable);
@@ -908,24 +901,31 @@ describe('HoloSphere', () => {
 
         test('should validate holon resolution', async () => {
             const invalidHolon = h3.latLngToCell(40.7128, -74.0060, 0); // Resolution 0
-            await expect(holoSphere.compute(invalidHolon, testLens, 'summarize'))
+            await expect(holoSphere.compute(invalidHolon, testLens, { operation: 'summarize' }))
                 .rejects.toThrow('compute: Invalid holon resolution (must be between 1 and 15)');
         });
 
         test('should validate depth parameters', async () => {
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', -1))
-                .rejects.toThrow('compute: Invalid depth parameter');
-
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', 0, 0))
-                .rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
-
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', 0, 16))
-                .rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                depth: -1
+            })).rejects.toThrow('compute: Invalid depth parameter');
+
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                maxDepth: 0
+            })).rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
+
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                maxDepth: 16
+            })).rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
         });
 
         test('should validate operation type', async () => {
-            await expect(holoSphere.compute(testHolon, testLens, 'invalid-operation'))
-                .rejects.toThrow('compute: Invalid operation (must be "summarize")');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'invalid-operation'
+            })).rejects.toThrow('compute: Invalid operation (must be one of summarize, aggregate, concatenate)');
         });
 
         afterEach(async () => {
@@ -967,8 +967,6 @@ describe('HoloSphere', () => {
             for (let i = 0; i < numOperations; i++) {
                 const id = `concurrent${i}`;
                 expectedIds.add(id);
-                // Add small delay between operations to prevent race conditions
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.put(testHolon, testLens, { 
                     id: id, 
                     data: 'test' 
@@ -978,9 +976,6 @@ describe('HoloSphere', () => {
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 500));
-
             // Get and verify results
             const results = await holoSphere.getAll(testHolon, testLens);
             const resultIds = new Set(results.map(r => r.id));

package/test/spacesauth.test.js

@@ -1,7 +1,5 @@
 import HoloSphere from '../holosphere.js';
 import * as h3 from 'h3-js';
-import Gun from 'gun';
-import 'gun/sea';
 
 describe('Space Authentication and Authorization', () => {
     // Global HoloSphere instances