holosphere 1.1.5 → 1.1.7

package/holosphere.js

@@ -3,7 +3,9 @@ import OpenAI from 'openai';
 import Gun from 'gun'
 import SEA from 'gun/sea.js'
 import Ajv2019 from 'ajv/dist/2019.js'
+import * as Federation from './federation.js';
 
+export { federateMessage, getFederatedMessages, updateFederatedMessages, removeNotify } from './federation.js';
 
 class HoloSphere {
     /**
@@ -14,7 +16,7 @@ class HoloSphere {
      * @param {Gun|null} gunInstance - The Gun instance to use.
      */
     constructor(appname, strict = false, openaikey = null, gunInstance = null) {
-        console.log('HoloSphere v1.1.8'); 
+        console.log('HoloSphere v1.1.7'); 
         this.appname = appname
         this.strict = strict;
         this.validator = new Ajv2019({
@@ -23,14 +25,17 @@ class HoloSphere {
             validateSchema: true // Always validate schemas
         });
 
-        // Use provided Gun instance or create new one
-        this.gun = gunInstance || Gun({
-            peers: ['https://gun.holons.io/gun'],
-            axe: false,
-            // uuid: (content) => { // generate a unique id for each node
-            //     console.log('uuid', content);
-            //     return content;}
-        });
+        // Handle different ways of providing Gun instance or options
+        if (gunInstance && gunInstance.opt) {
+            // If an object with 'opt' property is passed, create a new Gun instance with those options
+            this.gun = Gun(gunInstance.opt);
+        } else {
+            // Use provided Gun instance or create new one with default options
+            this.gun = gunInstance || Gun({
+                peers: ['https://gun.holons.io/gun'],
+                axe: false,
+            });
+        }
 
         // Initialize SEA
         this.sea = SEA;
@@ -41,9 +46,6 @@ class HoloSphere {
             });
         }
 
-        // Add currentSpace property to track logged in space
-        this.currentSpace = null;
-
         // Initialize subscriptions
         this.subscriptions = {};
     }
@@ -105,8 +107,7 @@ class HoloSphere {
         await this.putGlobal('schemas', {
             id: lens,
             schema: schema,
-            timestamp: Date.now(),
-            owner: this.currentSpace?.alias
+            timestamp: Date.now()
         });
 
         return true;
@@ -137,300 +138,439 @@ class HoloSphere {
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens under which to store the content.
      * @param {object} data - The data to store.
+     * @param {string} [password] - Optional password for private holon.
+     * @param {object} [options] - Additional options
+     * @param {boolean} [options.autoPropagate=true] - Whether to automatically propagate to federated holons (default: true)
+     * @param {object} [options.propagationOptions] - Options to pass to propagate
+     * @param {boolean} [options.propagationOptions.useReferences=true] - Whether to use references instead of duplicating data
      * @returns {Promise<boolean>} - Returns true if successful, false if there was an error
      */
-    async put(holon, lens, data) {
-        // Check authentication for data operations
-        if (!this.currentSpace) {
-            throw new Error('Unauthorized to modify this data');
-        }
-        this._checkSession();
-
-        // 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 &&
-                !existing.federation) { // Skip ownership check for federated data
-                throw new Error('Unauthorized to modify this data');
-            }
-        }
-
-        // Add owner and federation information to data
-        const dataWithMeta = {
-            ...data,
-            owner: this.currentSpace.alias,
-            federation: {
-                origin: this.currentSpace.alias,
-                timestamp: Date.now()
-            }
-        };
-
-        if (!holon || !lens || !dataWithMeta) {
-            throw new Error('put: Missing required parameters');
+    async put(holon, lens, data, password = null, options = {}) {
+        if (!holon || !lens || !data) {
+            throw new Error('put: Missing required parameters:',  holon, lens, data );
         }
 
-        if (!dataWithMeta.id) {
-            dataWithMeta.id = this.generateId();
+        if (!data.id) {
+            data.id = this.generateId();
         }
 
-        // Get and validate schema first
-        const schema = await this.getSchema(lens);
-        if (schema) {
-            // Deep clone data to avoid modifying the original
-            const dataToValidate = JSON.parse(JSON.stringify(dataWithMeta));
+        // Get and validate schema only in strict mode
+        if (this.strict) {
+            const schema = await this.getSchema(lens);
+            if (!schema) {
+                throw new Error('Schema required in strict mode');
+            }
+            const dataToValidate = JSON.parse(JSON.stringify(data));
             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
                 throw new Error(errorMsg);
             }
-        } else if (this.strict) {
-            throw new Error('Schema required in strict mode');
         }
 
-        // Store data in current space
-        const putResult = await new Promise((resolve, reject) => {
-            try {
-                const payload = JSON.stringify(dataWithMeta);
-                this.gun.get(this.appname)
-                    .get(holon)
-                    .get(lens)
-                    .get(dataWithMeta.id)
-                    .put(payload, ack => {
+        try {
+            const user = this.gun.user();
+            
+            if (password) {
+                try {
+                    await new Promise((resolve, reject) => {
+                        user.auth(this.userName(holon), password, (ack) => {
+                            if (ack.err) reject(new Error(ack.err));
+                            else resolve();
+                        });
+                    });
+                } catch (loginError) {
+                    // If authentication fails, try to create user and then authenticate
+                    try {
+                        await new Promise((resolve, reject) => {
+                            user.create(this.userName(holon), password, (ack) => {
+                                if (ack.err) {
+                                    // Don't reject if the user is already being created or already exists
+                                    if (ack.err.includes('already being created') || 
+                                        ack.err.includes('already created')) {
+                                        console.warn(`User creation note: ${ack.err}, continuing...`);
+                                        // Try to authenticate again
+                                        user.auth(this.userName(holon), password, (authAck) => {
+                                            if (authAck.err) {
+                                                if (authAck.err.includes('already being created') || 
+                                                    authAck.err.includes('already created')) {
+                                                    console.warn(`Auth note: ${authAck.err}, continuing...`);
+                                                    resolve(); // Continue anyway
+                                                } else {
+                                                    reject(new Error(authAck.err));
+                                                }
+                                            } else {
+                                                resolve();
+                                            }
+                                        });
+                                    } else {
+                                        reject(new Error(ack.err));
+                                    }
+                                } else {
+                                    user.auth(this.userName(holon), password, (authAck) => {
+                                        if (authAck.err) reject(new Error(authAck.err));
+                                        else resolve();
+                                    });
+                                }
+                            });
+                        });
+                    } catch (createError) {
+                        // Try one last authentication
+                        try {
+                            await new Promise((resolve, reject) => {
+                                setTimeout(() => {
+                                    user.auth(this.userName(holon), password, (ack) => {
+                                        if (ack.err) {
+                                            // Continue even if auth fails at this point
+                                            console.warn(`Final auth attempt note: ${ack.err}, continuing with limited functionality`);
+                                            resolve();
+                                        } else {
+                                            resolve();
+                                        }
+                                    });
+                                }, 100); // Short delay before retry
+                            });
+                        } catch (finalAuthError) {
+                            console.warn('All authentication attempts failed, continuing with limited functionality');
+                        }
+                    }
+                }
+            }
+
+            return new Promise((resolve, reject) => {
+                try {
+                    const payload = JSON.stringify(data);
+                    
+                    const putCallback = async (ack) => {
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
-                            // Notify subscribers after successful put
                             this.notifySubscribers({
                                 holon,
                                 lens,
-                                ...dataWithMeta
+                                ...data
+                            });
+                            
+                            // Auto-propagate to federation by default
+                            const shouldPropagate = options.autoPropagate !== false;
+                            let propagationResult = null;
+                            
+                            if (shouldPropagate) {
+                                try {
+                                    // Default to using references
+                                    const propagationOptions = {
+                                        useReferences: true,
+                                        ...options.propagationOptions
+                                    };
+                                    
+                                    propagationResult = await this.propagate(
+                                        holon, 
+                                        lens, 
+                                        data, 
+                                        propagationOptions
+                                    );
+                                    
+                                    // Still resolve with true even if propagation had errors
+                                    if (propagationResult.errors > 0) {
+                                        console.warn('Auto-propagation had errors:', propagationResult);
+                                    }
+                                } catch (propError) {
+                                    console.warn('Error in auto-propagation:', propError);
+                                }
+                            }
+                            
+                            resolve({
+                                success: true,
+                                propagationResult
                             });
-                            resolve(true);
                         }
-                    });
-            } catch (error) {
-                reject(error);
-            }
-        });
-
-        // If successful, propagate to federated spaces
-        if (putResult) {
-            await this._propagateToFederation(holon, lens, dataWithMeta);
+                    };
+                    
+                    if (password) {
+                        // For private data, use the authenticated user's holon
+                        user.get('private').get(lens).get(data.id).put(payload, putCallback);
+                    } else {
+                        // For public data, use the regular path
+                        this.gun.get(this.appname).get(holon).get(lens).get(data.id).put(payload, putCallback);
+                    }
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        } catch (error) {
+            console.error('Error in put:', error);
+            throw error;
         }
-
-        return putResult;
     }
 
     /**
-     * Propagates data to federated spaces
-     * @private
-     * @param {string} holon - The holon identifier
-     * @param {string} lens - The lens identifier
-     * @param {object} data - The data to propagate
+     * Retrieves content from the specified holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens from which to retrieve content.
+     * @param {string} key - The specific key to retrieve.
+     * @param {string} [password] - Optional password for private holon.
+     * @param {object} [options] - Additional options
+     * @param {boolean} [options.resolveReferences=true] - Whether to automatically resolve federation references
+     * @returns {Promise<object|null>} - The retrieved content or null if not found.
      */
-    async _propagateToFederation(holon, lens, data) {
+    async get(holon, lens, key, password = null, options = {}) {
+        if (!holon || !lens || !key) {
+            console.error('get: Missing required parameters:', { holon, lens, key });
+            return null;
+        }
+
+        const { resolveReferences = true } = options;
+
+        // Only check schema in strict mode
+        let schema;
+        if (this.strict) {
+            schema = await this.getSchema(lens);
+            if (!schema) {
+                throw new Error('Schema required in strict mode');
+            }
+        }
+
         try {
-            // Get federation info for current space
-            const fedInfo = await this.getFederation(this.currentSpace.alias);
-            if (!fedInfo || !fedInfo.notify || fedInfo.notify.length === 0) {
-                return; // No federation to propagate to
+            const user = this.gun.user();
+            
+            if (password) {
+                try {
+                    await new Promise((resolve, reject) => {
+                        user.auth(this.userName(holon), password, (ack) => {
+                            if (ack.err) reject(new Error(ack.err));
+                            else resolve();
+                        });
+                    });
+                } catch (loginError) {
+                    // If authentication fails, try to create user and then authenticate
+                    await new Promise((resolve, reject) => {
+                        user.create(this.userName(holon), password, (ack) => {
+                            if (ack.err) reject(new Error(ack.err));
+                            else {
+                                user.auth(this.userName(holon), password, (authAck) => {
+                                    if (authAck.err) reject(new Error(authAck.err));
+                                    else resolve();
+                                });
+                            }
+                        });
+                    });
+                }
             }
 
-            // Propagate to each federated space
-            const propagationPromises = fedInfo.notify.map(spaceId =>
-                new Promise((resolve) => {
-                    // Store data in the federated space's lens
-                    this.gun.get(this.appname)
-                        .get(spaceId)
-                        .get(lens)
-                        .get(data.id)
-                        .put(JSON.stringify({
-                            ...data,
-                            federation: {
-                                ...data.federation,
-                                notified: Date.now()
+            return new Promise((resolve) => {
+                const handleData = async (data) => {
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
+
+                    try {
+                        const parsed = await this.parse(data);
+
+                        if (!parsed) {
+                            resolve(null);
+                            return;
+                        }
+
+                        // Check if this is a reference that needs to be resolved
+                        if (resolveReferences !== false && parsed) {
+                            // Check if this is a simple reference (id + soul)
+                            if (parsed.soul) {
+                                console.log(`Resolving simple reference with soul: ${parsed.soul}`);
+                                try {
+                                    // For direct soul resolution, we need to parse the soul to get the right path
+                                    const soulParts = parsed.soul.split('/');
+                                    if (soulParts.length >= 4) {  // Expected format: appname/holon/lens/key
+                                        const originHolon = soulParts[1];
+                                        const originLens = soulParts[2];
+                                        const originKey = soulParts[3];
+                                        
+                                        console.log(`Extracting from soul - holon: ${originHolon}, lens: ${originLens}, key: ${originKey}`);
+                                        
+                                        // Get original data using the extracted path components
+                                        const originalData = await this.get(
+                                            originHolon,
+                                            originLens,
+                                            originKey,
+                                            null,
+                                            { resolveReferences: false } // Prevent infinite recursion
+                                        );
+                                        
+                                        if (originalData) {
+                                            console.log(`Original data found through soul path resolution:`, originalData);
+                                            resolve({
+                                                ...originalData,
+                                                _federation: {
+                                                    isReference: true,
+                                                    resolved: true,
+                                                    soul: parsed.soul,
+                                                    timestamp: Date.now()
+                                                }
+                                            });
+                                            return;
+                                        } else {
+                                            console.warn(`Could not resolve reference: original data not found at extracted path`);
+                                        }
+                                    } else {
+                                        console.warn(`Soul doesn't match expected format: ${parsed.soul}`);
+                                    }
+                                } catch (error) {
+                                    console.warn(`Error resolving reference by soul: ${error.message}`);
+                                }
                             }
-                        }), ack => {
-                            if (ack.err) {
-                                console.warn(`Failed to propagate to space ${spaceId}:`, ack.err);
+                            // Legacy federation reference
+                            else if (parsed._federation && parsed._federation.isReference) {
+                                console.log(`Resolving legacy federation reference from ${parsed._federation.origin}`);
+                                try {
+                                    const reference = parsed._federation;
+                                    const originalData = await this.get(
+                                        reference.origin,
+                                        reference.lens,
+                                        key,
+                                        null,
+                                        { resolveReferences: false } // Prevent infinite recursion
+                                    );
+                                    
+                                    if (originalData) {
+                                        return {
+                                            ...originalData,
+                                            _federation: {
+                                                ...reference,
+                                                resolved: true,
+                                                timestamp: Date.now()
+                                            }
+                                        };
+                                    } else {
+                                        console.warn(`Could not resolve legacy reference: original data not found`);
+                                        return parsed; // Return the reference if we can't resolve it
+                                    }
+                                } catch (error) {
+                                    console.warn(`Error resolving legacy reference: ${error.message}`);
+                                    return parsed;
+                                }
                             }
-                            resolve();
-                        });
+                        }
 
-                    // Also store in federation lens for notifications
-                    this.gun.get(this.appname)
-                        .get(spaceId)
-                        .get('federation')
-                        .get(data.id)
-                        .put(JSON.stringify({
-                            ...data,
-                            federation: {
-                                ...data.federation,
-                                notified: Date.now()
+                        if (schema) {
+                            const valid = this.validator.validate(schema, parsed);
+                            if (!valid) {
+                                console.error('get: Invalid data according to schema:', this.validator.errors);
+                                if (this.strict) {
+                                    resolve(null);
+                                    return;
+                                }
                             }
-                        }));
-                })
-            );
+                        }
+
+                        resolve(parsed);
+                    } catch (error) {
+                        console.error('Error parsing data:', error);
+                        resolve(null);
+                    }
+                };
 
-            await Promise.all(propagationPromises);
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(lens).get(key).once(handleData);
+                } else {
+                    // For public data, use the regular path
+                    this.gun.get(this.appname).get(holon).get(lens).get(key).once(handleData);
+                }
+            });
         } catch (error) {
-            console.warn('Federation propagation error:', error);
-            // Don't throw here to avoid failing the original put
+            console.error('Error in get:', error);
+            return null;
         }
     }
 
     /**
-     * Retrieves content from the specified holon and lens.
-     * @param {string} holon - The holon identifier.
-     * @param {string} lens - The lens from which to retrieve content.
-     * @returns {Promise<Array<object>>} - The retrieved content.
+     * Retrieves a node directly using its soul path
+     * @param {string} soul - The soul path of the node
+     * @returns {Promise<any>} - The retrieved node or null if not found.
      */
-    async getAll(holon, lens) {
-        if (!holon || !lens) {
-            throw new Error('getAll: Missing required parameters');
+    async getNodeBySoul(soul) {
+        if (!soul) {
+            throw new Error('getNodeBySoul: Missing soul parameter');
         }
 
-        const schema = await this.getSchema(lens);
-        if (!schema && this.strict) {
-            throw new Error('getAll: Schema required in strict mode');
-        }
-
-        // Get local data
-        const localData = await this._getAllLocal(holon, lens, schema);
-
-        // If authenticated, get federated data
-        let federatedData = [];
-        if (this.currentSpace) {
-            federatedData = await this._getAllFederated(holon, lens, schema);
-        }
+        console.log(`getNodeBySoul: Accessing soul ${soul}`);
 
-        // Combine and deduplicate data based on ID
-        const combined = new Map();
-
-        // Add local data first
-        localData.forEach(item => {
-            if (item.id) {
-                combined.set(item.id, item);
-            }
-        });
-
-        // Add federated data, potentially overwriting local data if newer
-        federatedData.forEach(item => {
-            if (item.id) {
-                const existing = combined.get(item.id);
-                if (!existing ||
-                    (item.federation?.timestamp > (existing.federation?.timestamp || 0))) {
-                    combined.set(item.id, item);
-                }
+        return new Promise((resolve) => {
+            try {
+                const ref = this.getNodeRef(soul);
+                ref.once((data) => {
+                    console.log(`getNodeBySoul: Retrieved data:`, data);
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
+                    resolve(data);  // Return the data directly
+                });
+            } catch (error) {
+                console.error(`getNodeBySoul error:`, error);
+                resolve(null);
             }
         });
-
-        return Array.from(combined.values());
     }
 
     /**
-     * Gets data from federated spaces
-     * @private
+     * Propagates data to federated holons
      * @param {string} holon - The holon identifier
      * @param {string} lens - The lens identifier
-     * @param {string} key - The key to get
-     * @returns {Promise<object|null>} - The federated data or null if not found
+     * @param {object} data - The data to propagate
+     * @param {object} [options] - Propagation options
+     * @returns {Promise<object>} - Result with success count and errors
      */
-    async _getFederatedData(holon, lens, key) {
-        try {
-            const fedInfo = await this.getFederation(this.currentSpace.alias);
-            if (!fedInfo || !fedInfo.federation || fedInfo.federation.length === 0) {
-                return null;
-            }
-
-            // Try each federated space
-            for (const spaceId of fedInfo.federation) {
-                const result = await new Promise((resolve) => {
-                    this.gun.get(this.appname)
-                        .get(spaceId)
-                        .get(lens)
-                        .get(key)
-                        .once(async (data) => {
-                            if (!data) {
-                                resolve(null);
-                                return;
-                            }
-                            try {
-                                const parsed = await this.parse(data);
-                                resolve(parsed);
-                            } catch (error) {
-                                console.warn(`Error parsing federated data from ${spaceId}:`, error);
-                                resolve(null);
-                            }
-                        });
-                });
-
-                if (result) {
-                    return result;
-                }
-            }
-        } catch (error) {
-            console.warn('Federation get error:', error);
-        }
-        return null;
+    async propagate(holon, lens, data, options = {}) {
+        return Federation.propagate(this, holon, lens, data, options);
     }
 
     /**
-     * Gets all data from local space
-     * @private
-     * @param {string} holon - The holon identifier
-     * @param {string} lens - The lens identifier
-     * @param {object} schema - The schema to validate against
-     * @returns {Promise<Array>} - Array of local data
+     * Retrieves all content from the specified holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens from which to retrieve content.
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<Array<object>>} - The retrieved content.
      */
-    async _getAllLocal(holon, lens, schema) {
-        return new Promise((resolve) => {
-            const output = new Map();
-            let isResolved = false;
-            let listener = null;
-
-            const hardTimeout = setTimeout(() => {
-                cleanup();
-                resolve(Array.from(output.values()));
-            }, 5000);
-
-            const cleanup = () => {
-                if (listener) {
-                    listener.off();
-                }
-                clearTimeout(hardTimeout);
-                isResolved = true;
-            };
+    async getAll(holon, lens, password = null) {
+        if (!holon || !lens) {
+            throw new Error('getAll: Missing required parameters');
+        }
 
-            const processData = async (data, key) => {
-                if (!data || key === '_') return;
+        const schema = await this.getSchema(lens);
+        if (!schema && this.strict) {
+            throw new Error('getAll: Schema required in strict mode');
+        }
 
-                try {
-                    const parsed = await this.parse(data);
-                    if (!parsed || !parsed.id) return;
+        try {
+            const user = this.gun.user();
+
+            return new Promise((resolve) => {
+                const output = new Map();
 
-                    if (schema) {
-                        const valid = this.validator.validate(schema, parsed);
-                        if (valid || !this.strict) {
+                const processData = async (data, key) => {
+                    if (!data || key === '_') return;
+
+                    try {
+                        const parsed = await this.parse(data);
+                        if (!parsed || !parsed.id) return;
+
+                        if (schema) {
+                            const valid = this.validator.validate(schema, parsed);
+                            if (valid || !this.strict) {
+                                output.set(parsed.id, parsed);
+                            }
+                        } else {
                             output.set(parsed.id, parsed);
                         }
-                    } else {
-                        output.set(parsed.id, parsed);
+                    } catch (error) {
+                        console.error('Error processing data:', error);
                     }
-                } catch (error) {
-                    console.error('Error processing data:', error);
-                }
-            };
+                };
 
-            this.gun.get(this.appname)
-                .get(holon)
-                .get(lens)
-                .once(async (data) => {
+                const handleData = async (data) => {
                     if (!data) {
-                        cleanup();
                         resolve([]);
                         return;
                     }
@@ -444,75 +584,23 @@ class HoloSphere {
 
                     try {
                         await Promise.all(initialPromises);
-                        cleanup();
                         resolve(Array.from(output.values()));
                     } catch (error) {
-                        cleanup();
+                        console.error('Error in getAll:', error);
                         resolve([]);
                     }
-                });
-        });
-    }
-
-    /**
-     * Gets all data from federated spaces
-     * @private
-     * @param {string} holon - The holon identifier
-     * @param {string} lens - The lens identifier
-     * @param {object} schema - The schema to validate against
-     * @returns {Promise<Array>} - Array of federated data
-     */
-    async _getAllFederated(holon, lens, schema) {
-        try {
-            const fedInfo = await this.getFederation(this.currentSpace.alias);
-            if (!fedInfo || !fedInfo.federation || fedInfo.federation.length === 0) {
-                return [];
-            }
+                };
 
-            const federatedData = new Map();
-
-            // Get data from each federated space
-            const fedPromises = fedInfo.federation.map(spaceId =>
-                new Promise((resolve) => {
-                    this.gun.get(this.appname)
-                        .get(spaceId)
-                        .get(lens)
-                        .once(async (data) => {
-                            if (!data) {
-                                resolve();
-                                return;
-                            }
-
-                            const processPromises = Object.keys(data)
-                                .filter(key => key !== '_')
-                                .map(async key => {
-                                    try {
-                                        const parsed = await this.parse(data[key]);
-                                        if (parsed && parsed.id) {
-                                            if (schema) {
-                                                const valid = this.validator.validate(schema, parsed);
-                                                if (valid || !this.strict) {
-                                                    federatedData.set(parsed.id, parsed);
-                                                }
-                                            } else {
-                                                federatedData.set(parsed.id, parsed);
-                                            }
-                                        }
-                                    } catch (error) {
-                                        console.warn(`Error processing federated data from ${spaceId}:`, error);
-                                    }
-                                });
-
-                            await Promise.all(processPromises);
-                            resolve();
-                        });
-                })
-            );
-
-            await Promise.all(fedPromises);
-            return Array.from(federatedData.values());
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(lens).once(handleData);
+                } else {
+                    // For public data, use the regular path
+                    this.gun.get(this.appname).get(holon).get(lens).once(handleData);
+                }
+            });
         } catch (error) {
-            console.warn('Federation getAll error:', error);
+            console.error('Error in getAll:', error);
             return [];
         }
     }
@@ -575,186 +663,116 @@ class HoloSphere {
         }
     }
 
-    /**
-     * Retrieves a specific key from the specified holon and lens.
-     * @param {string} holon - The holon identifier.
-     * @param {string} lens - The lens from which to retrieve the key.
-     * @param {string} key - The specific key to retrieve.
-     * @returns {Promise<object|null>} - The retrieved content or null if not found.
-     */
-    async get(holon, lens, key) {
-        if (!holon || !lens || !key) {
-            console.error('get: Missing required parameters:', { holon, lens, key });
-            return null;
-        }
-
-        // Get schema for validation
-        const schema = await this.getSchema(lens);
-
-        // First try to get from current space
-        const localResult = await new Promise((resolve) => {
-            let timeout = setTimeout(() => {
-                console.warn('get: Operation timed out');
-                resolve(null);
-            }, 5000);
-
-            this.gun.get(this.appname)
-                .get(holon)
-                .get(lens)
-                .get(key)
-                .once(async (data) => {
-                    clearTimeout(timeout);
-
-                    if (!data) {
-                        resolve(null);
-                        return;
-                    }
-
-                    try {
-                        const parsed = await this.parse(data);
-
-                        // Validate against schema if one exists
-                        if (schema) {
-                            const valid = this.validator.validate(schema, parsed);
-                            if (!valid) {
-                                console.error('get: Invalid data according to schema:', this.validator.errors);
-                                if (this.strict) {
-                                    resolve(null);
-                                    return;
-                                }
-                            }
-                        }
-
-                        // Check if user has access - only allow if:
-                        // 1. No owner (public data)
-                        // 2. User is the owner
-                        // 3. User is in shared list
-                        // 4. Data is from federation
-                        if (parsed.owner &&
-                            this.currentSpace?.alias !== parsed.owner &&
-                            (!parsed.shared || !parsed.shared.includes(this.currentSpace?.alias)) &&
-                            (!parsed.federation || !parsed.federation.origin)) {
-                            resolve(null);
-                            return;
-                        }
-
-                        resolve(parsed);
-                    } catch (error) {
-                        console.error('Error parsing data:', error);
-                        resolve(null);
-                    }
-                });
-        });
-
-        // If found locally, return it
-        if (localResult) {
-            return localResult;
-        }
-
-        // If not found locally and we're authenticated, try federated spaces
-        if (this.currentSpace) {
-            const fedResult = await this._getFederatedData(holon, lens, key);
-            if (fedResult) {
-                return fedResult;
-            }
-        }
-
-        return null;
-    }
-
     /**
      * Deletes a specific key from a given holon and lens.
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens from which to delete the key.
      * @param {string} key - The specific key to delete.
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<boolean>} - Returns true if successful
      */
-    async delete(holon, lens, key) {
+    async delete(holon, lens, key, password = null) {
         if (!holon || !lens || !key) {
             throw new Error('delete: Missing required parameters');
         }
 
-        if (!this.currentSpace) {
-            throw new Error('Unauthorized to delete this data');
-        }
-        this._checkSession();
-
-        // Check ownership before delete
-        const data = await this.get(holon, lens, key);
-        if (!data) {
-            return true; // Nothing to delete
-        }
-
-        if (data.owner && data.owner !== this.currentSpace.alias) {
-            throw new Error('Unauthorized to delete this data');
-        }
-
-        return new Promise((resolve, reject) => {
-            try {
-                this.gun.get(this.appname)
-                    .get(holon)
-                    .get(lens)
-                    .get(key)
-                    .put(null, ack => {
+        try {
+            // Get the appropriate holon
+            const user = this.gun.user();
+
+            // Delete data from holon
+            return new Promise((resolve, reject) => {
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(lens).get(key).put(null, ack => {
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
                             resolve(true);
                         }
                     });
-            } catch (error) {
-                reject(error);
-            }
-        });
+                } else {
+                    // For public data, use the regular path
+                    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) {
+            console.error('Error in delete:', error);
+            throw error;
+        }
     }
 
     /**
      * Deletes all keys from a given holon and lens.
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens from which to delete all keys.
-     * @returns {Promise<boolean>} - Returns true if successful, false if there was an error
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<boolean>} - Returns true if successful
      */
-    async deleteAll(holon, lens) {
+    async deleteAll(holon, lens, password = null) {
         if (!holon || !lens) {
             console.error('deleteAll: Missing holon or lens parameter');
             return false;
         }
 
-        return new Promise((resolve) => {
-            let deletionPromises = [];
+        try {
+            // Get the appropriate holon
+            const user = this.gun.user();
+
+            return new Promise((resolve) => {
+                let deletionPromises = [];
+                
+                const dataPath = password ? 
+                    user.get('private').get(lens) :
+                    this.gun.get(this.appname).get(holon).get(lens);
+
+                // First get all the data to find keys to delete
+                dataPath.once((data) => {
+                    if (!data) {
+                        resolve(true); // Nothing to delete
+                        return;
+                    }
 
-            // First get all the data to find keys to delete
-            this.gun.get(this.appname).get(holon).get(lens).once((data) => {
-                if (!data) {
-                    resolve(true); // Nothing to delete
-                    return;
-                }
+                    // Get all keys except Gun's metadata key '_'
+                    const keys = Object.keys(data).filter(key => key !== '_');
 
-                // 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(
+                            new Promise((resolveDelete) => {
+                                const deletePath = password ? 
+                                    user.get('private').get(lens).get(key) :
+                                    this.gun.get(this.appname).get(holon).get(lens).get(key);
 
-                // Create deletion promises for each key
-                keys.forEach(key => {
-                    deletionPromises.push(
-                        new Promise((resolveDelete) => {
-                            this.gun.get(this.appname).get(holon).get(lens).get(key).put(null, ack => {
-                                resolveDelete(!!ack.ok); // Convert to boolean
-                            });
+                                deletePath.put(null, ack => {
+                                    resolveDelete(!!ack.ok); // Convert to boolean
+                                });
+                            })
+                        );
+                    });
+
+                    // Wait for all deletions to complete
+                    Promise.all(deletionPromises)
+                        .then(results => {
+                            const allSuccessful = results.every(result => result === true);
+                            resolve(allSuccessful);
                         })
-                    );
+                        .catch(error => {
+                            console.error('Error in deleteAll:', error);
+                            resolve(false);
+                        });
                 });
-
-                // Wait for all deletions to complete
-                Promise.all(deletionPromises)
-                    .then(results => {
-                        const allSuccessful = results.every(result => result === true);
-                        resolve(allSuccessful);
-                    })
-                    .catch(error => {
-                        console.error('Error in deleteAll:', error);
-                        resolve(false);
-                    });
             });
-        });
+        } catch (error) {
+            console.error('Error in deleteAll:', error);
+            return false;
+        }
     }
 
     // ================================ NODE FUNCTIONS ================================
@@ -871,243 +889,418 @@ class HoloSphere {
      * Stores data in a global (non-holon-specific) table.
      * @param {string} tableName - The table name to store data in.
      * @param {object} data - The data to store. If it has an 'id' field, it will be used as the key.
+     * @param {string} [password] - Optional password for private holon.
      * @returns {Promise<void>}
      */
-    async putGlobal(tableName, data) {
-        return new Promise((resolve, reject) => {
-            try {
-                if (!tableName || !data) {
-                    throw new Error('Table name and data are required');
-                }
+    async putGlobal(tableName, data, password = null) {
+        try {
+            if (!tableName || !data) {
+                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) {
-                            reject(new Error(ack.err));
-                        } else {
-                            resolve();
-                        }
-                    });
-                } else {
-                    this.gun.get(this.appname).get(tableName).put(JSON.stringify(data), ack => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            resolve();
-                        }
+            const user = this.gun.user();
+            
+            if (password) {
+                try {
+                    // Try to authenticate first
+                    await new Promise((resolve, reject) => {
+                        user.auth(this.userName(tableName), password, (ack) => {
+                            if (ack.err) {
+                                // Handle wrong username/password gracefully
+                                if (ack.err.includes('Wrong user or password') || 
+                                    ack.err.includes('No user')) {
+                                    console.warn(`Authentication failed for ${tableName}: ${ack.err}`);
+                                    // Will try to create user next
+                                    reject(new Error(ack.err));
+                                } else {
+                                    reject(new Error(ack.err));
+                                }
+                            } else {
+                                resolve();
+                            }
+                        });
                     });
+                } catch (authError) {
+                    // If authentication fails, try to create user
+                    try {
+                        await new Promise((resolve, reject) => {
+                            user.create(this.userName(tableName), password, (ack) => {
+                                // Handle "User already created!" error gracefully
+                                if (ack.err && !ack.err.includes('already created')) {
+                                    reject(new Error(ack.err));
+                                } else {
+                                    // Whether user was created or already existed, try to authenticate
+                                    user.auth(this.userName(tableName), password, (authAck) => {
+                                        if (authAck.err) {
+                                            console.warn(`Authentication failed after creation for ${tableName}: ${authAck.err}`);
+                                            reject(new Error(authAck.err));
+                                        } else {
+                                            resolve();
+                                        }
+                                    });
+                                }
+                            });
+                        });
+                    } catch (createError) {
+                        // If both auth and create fail, try one last auth attempt
+                        await new Promise((resolve, reject) => {
+                            user.auth(this.userName(tableName), password, (ack) => {
+                                if (ack.err) {
+                                    console.warn(`Final authentication attempt failed for ${tableName}: ${ack.err}`);
+                                    // Continue with operation even if auth fails
+                                    resolve();
+                                } else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
                 }
-            } catch (error) {
-                reject(error);
             }
-        });
+
+            return new Promise((resolve, reject) => {
+                const payload = JSON.stringify(data);
+                
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    const path = user.get('private').get(tableName);
+                    
+                    if (data.id) {
+                        path.get(data.id).put(payload, ack => {
+                            if (ack.err) {
+                                reject(new Error(ack.err));
+                            } else {
+                                resolve();
+                            }
+                        });
+                    } else {
+                        path.put(payload, ack => {
+                            if (ack.err) {
+                                reject(new Error(ack.err));
+                            } else {
+                                resolve();
+                            }
+                        });
+                    }
+                } else {
+                    // For public data, use the regular path
+                    const path = this.gun.get(this.appname).get(tableName);
+                    
+                    if (data.id) {
+                        path.get(data.id).put(payload, ack => {
+                            if (ack.err) {
+                                reject(new Error(ack.err));
+                            } else {
+                                resolve();
+                            }
+                        });
+                    } else {
+                        path.put(payload, ack => {
+                            if (ack.err) {
+                                reject(new Error(ack.err));
+                            } else {
+                                resolve();
+                            }
+                        });
+                    }
+                }
+            });
+        } catch (error) {
+            console.error('Error in putGlobal:', error);
+            throw error;
+        }
     }
 
     /**
-    * Retrieves a specific key from a global table.
-    * @param {string} tableName - The table name to retrieve from.
-    * @param {string} key - The key to retrieve.
-    * @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;
-                }
+     * Retrieves a specific key from a global table.
+     * @param {string} tableName - The table name to retrieve from.
+     * @param {string} key - The key to retrieve.
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<object|null>} - The parsed data for the key or null if not found.
+     */
+    async getGlobal(tableName, key, password = null) {
+        try {
+            const user = this.gun.user();
+            
+            if (password) {
                 try {
-                    const parsed = this.parse(data);
-                    resolve(parsed);
-                } catch (e) {
-                    resolve(null);
+                    await new Promise((resolve, reject) => {
+                        user.auth(this.userName(tableName), password, (ack) => {
+                            if (ack.err) {
+                                // Handle wrong username/password gracefully
+                                if (ack.err.includes('Wrong user or password') || 
+                                    ack.err.includes('No user')) {
+                                    console.warn(`Authentication failed for ${tableName}: ${ack.err}`);
+                                    // Will try to create user next
+                                    reject(new Error(ack.err));
+                                } else {
+                                    reject(new Error(ack.err));
+                                }
+                            } else {
+                                resolve();
+                            }
+                        });
+                    });
+                } catch (loginError) {
+                    // If authentication fails, try to create user and then authenticate
+                    await new Promise((resolve, reject) => {
+                        user.create(this.userName(tableName), password, (ack) => {
+                            // Handle "User already created!" error gracefully
+                            if (ack.err && !ack.err.includes('already created')) {
+                                reject(new Error(ack.err));
+                            } else {
+                                user.auth(this.userName(tableName), password, (authAck) => {
+                                    if (authAck.err) {
+                                        console.warn(`Authentication failed after creation for ${tableName}: ${authAck.err}`);
+                                        // Continue with operation even if auth fails
+                                        resolve();
+                                    } else {
+                                        resolve();
+                                    }
+                                });
+                            }
+                        });
+                    });
+                }
+            }
+
+            return new Promise((resolve) => {
+                const handleData = (data) => {
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
+                    try {
+                        const parsed = this.parse(data);
+                        resolve(parsed);
+                    } catch (e) {
+                        resolve(null);
+                    }
+                };
+                
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(tableName).get(key).once(handleData);
+                } else {
+                    // For public data, use the regular path
+                    this.gun.get(this.appname).get(tableName).get(key).once(handleData);
                 }
             });
-        });
+        } catch (error) {
+            console.error('Error in getGlobal:', error);
+            return null;
+        }
     }
 
-
-
     /**
      * Retrieves all data from a global table.
      * @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.
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<Array<object>>} - The parsed data from the table as an array.
      */
-    async getAllGlobal(tableName) {
+    async getAllGlobal(tableName, password = null) {
         if (!tableName) {
             throw new Error('getAllGlobal: Missing table name parameter');
         }
 
-        return new Promise((resolve) => {
-            let output = [];
-            let isResolved = false;
-            let timeout = setTimeout(() => {
-                if (!isResolved) {
-                    isResolved = true;
-                    resolve(output);
-                }
-            }, 5000);
+        try {
+            // Get the appropriate holon
+            const user = this.gun.user();
 
-            this.gun.get(this.appname).get(tableName).once(async (data) => {
-                if (!data) {
-                    clearTimeout(timeout);
-                    isResolved = true;
-                    resolve([]);
-                    return;
-                }
+            return new Promise((resolve) => {
+                let output = [];
+                let isResolved = false;
+                let timeout = setTimeout(() => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve(output);
+                    }
+                }, 5000);
 
-                const keys = Object.keys(data).filter(key => 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);
-                        });
+                const handleData = async (data) => {
+                    if (!data) {
+                        clearTimeout(timeout);
+                        isResolved = true;
+                        resolve([]);
+                        return;
+                    }
 
-                        if (itemData) {
-                            try {
-                                const parsed = await this.parse(itemData);
-                                if (parsed) output.push(parsed);
-                            } catch (error) {
-                                console.error('Error parsing data:', error);
+                    const keys = Object.keys(data).filter(key => key !== '_');
+                    const promises = keys.map(key =>
+                        new Promise(async (resolveItem) => {
+                            const itemPath = password ? 
+                                user.get('private').get(tableName).get(key) :
+                                this.gun.get(this.appname).get(tableName).get(key);
+
+                            const itemData = await new Promise(resolveData => {
+                                itemPath.once(resolveData);
+                            });
+
+                            if (itemData) {
+                                try {
+                                    const parsed = await this.parse(itemData);
+                                    if (parsed) output.push(parsed);
+                                } catch (error) {
+                                    console.error('Error parsing data:', error);
+                                }
                             }
-                        }
-                        resolveItem();
-                    })
-                );
-
-                await Promise.all(promises);
-                clearTimeout(timeout);
-                if (!isResolved) {
-                    isResolved = true;
-                    resolve(output);
+                            resolveItem();
+                        })
+                    );
+
+                    await Promise.all(promises);
+                    clearTimeout(timeout);
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve(output);
+                    }
+                };
+
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(tableName).once(handleData);
+                } else {
+                    // For public data, use the regular path
+                    this.gun.get(this.appname).get(tableName).once(handleData);
                 }
             });
-        });
+        } catch (error) {
+            console.error('Error in getAllGlobal:', error);
+            return [];
+        }
     }
+
     /**
      * Deletes a specific key from a global table.
      * @param {string} tableName - The table name to delete from.
      * @param {string} key - The key to delete.
-     * @returns {Promise<void>}
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<boolean>}
      */
-    async deleteGlobal(tableName, key) {
+    async deleteGlobal(tableName, key, password = null) {
         if (!tableName || !key) {
             throw new Error('deleteGlobal: Missing required parameters');
         }
 
-        // Only check authentication for non-spaces tables
-        if (tableName !== 'spaces' && !this.currentSpace) {
-            throw new Error('Unauthorized to delete this data');
-        }
-
-        // Skip session check for spaces table
-        if (tableName !== 'spaces') {
-            this._checkSession();
-        }
+        try {
+            // Get the appropriate holon
+            const user = this.gun.user();
 
-        return new Promise((resolve, reject) => {
-            try {
-                this.gun.get(this.appname)
-                    .get(tableName)
-                    .get(key)
-                    .put(null, ack => {
+            return new Promise((resolve, reject) => {
+                if (password) {
+                    // For private data, use the authenticated user's holon
+                    user.get('private').get(tableName).get(key).put(null, ack => {
                         if (ack.err) {
                             reject(new Error(ack.err));
                         } else {
                             resolve(true);
                         }
                     });
-            } catch (error) {
-                reject(error);
-            }
-        });
+                } else {
+                    // For public data, use the regular path
+                    this.gun.get(this.appname).get(tableName).get(key).put(null, ack => {
+                        if (ack.err) {
+                            reject(new Error(ack.err));
+                        } else {
+                            resolve(true);
+                        }
+                    });
+                }
+            });
+        } catch (error) {
+            console.error('Error in deleteGlobal:', error);
+            throw error;
+        }
     }
 
     /**
      * Deletes an entire global table.
      * @param {string} tableName - The table name to delete.
-     * @returns {Promise<void>}
+     * @param {string} [password] - Optional password for private holon.
+     * @returns {Promise<boolean>}
      */
-    async deleteAllGlobal(tableName) {
+    async deleteAllGlobal(tableName, password = null) {
         if (!tableName) {
             throw new Error('deleteAllGlobal: Missing table name parameter');
         }
 
-        // Only check authentication for non-spaces and non-federation tables
-        if (!['spaces', 'federation'].includes(tableName) && !this.currentSpace) {
-            throw new Error('Unauthorized to delete this data');
-        }
+        try {
+            // Get the appropriate holon
+            const user = this.gun.user();
 
-        // Skip session check for spaces and federation tables
-        if (!['spaces', 'federation'].includes(tableName)) {
-            this._checkSession();
-        }
+            return new Promise((resolve, reject) => {
+                try {
+                    const deletions = new Set();
+                    let timeout = setTimeout(() => {
+                        if (deletions.size === 0) {
+                            resolve(true); // No data to delete
+                        }
+                    }, 5000);
 
-        return new Promise((resolve, reject) => {
-            try {
-                const deletions = new Set();
-                let timeout = setTimeout(() => {
-                    if (deletions.size === 0) {
-                        resolve(true); // No data to delete
-                    }
-                }, 5000);
+                    const dataPath = password ? 
+                        user.get('private').get(tableName) :
+                        this.gun.get(this.appname).get(tableName);
 
-                this.gun.get(this.appname).get(tableName).once(async (data) => {
-                    if (!data) {
-                        clearTimeout(timeout);
-                        resolve(true);
-                        return;
-                    }
+                    dataPath.once(async (data) => {
+                        if (!data) {
+                            clearTimeout(timeout);
+                            resolve(true);
+                            return;
+                        }
 
-                    const keys = Object.keys(data).filter(key => key !== '_');
-                    const promises = keys.map(key =>
-                        new Promise((resolveDelete) => {
-                            this.gun.get(this.appname)
-                                .get(tableName)
-                                .get(key)
-                                .put(null, ack => {
+                        const keys = Object.keys(data).filter(key => key !== '_');
+                        const promises = keys.map(key =>
+                            new Promise((resolveDelete) => {
+                                const deletePath = password ? 
+                                    user.get('private').get(tableName).get(key) :
+                                    this.gun.get(this.appname).get(tableName).get(key);
+
+                                deletePath.put(null, ack => {
                                     if (ack.err) {
                                         console.error(`Failed to delete ${key}:`, ack.err);
                                     }
                                     resolveDelete();
                                 });
-                        })
-                    );
-
-                    try {
-                        await Promise.all(promises);
-                        // Finally delete the table itself
-                        this.gun.get(this.appname).get(tableName).put(null);
-                        clearTimeout(timeout);
-                        resolve(true);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-            } catch (error) {
-                reject(error);
-            }
-        });
+                            })
+                        );
+
+                        try {
+                            await Promise.all(promises);
+                            // Finally delete the table itself
+                            dataPath.put(null);
+                            clearTimeout(timeout);
+                            resolve(true);
+                        } catch (error) {
+                            reject(error);
+                        }
+                    });
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        } catch (error) {
+            console.error('Error in deleteAllGlobal:', error);
+            throw error;
+        }
     }
 
     // ================================ COMPUTE FUNCTIONS ================================
     /**
-   
-   /**
- * 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) {
+     * 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
+     * @param {string} [password] - Optional password for private holons
+     */
+    async computeHierarchy(holon, lens, options, maxLevels = 15, password = null) {
         let currentHolon = holon;
         let currentRes = h3.getResolution(currentHolon);
         const results = [];
 
         while (currentRes > 0 && maxLevels > 0) {
             try {
-                const result = await this.compute(currentHolon, lens, options);
+                const result = await this.compute(currentHolon, lens, options, password);
                 if (result) {
                     results.push(result);
                 }
@@ -1123,16 +1316,18 @@ class HoloSphere {
         return results;
     }
 
-    /* Computes operations on content within a holon and lens for one layer up.
+    /**
+     * 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 {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
+     * @param {string} [password] - Optional password for private holons
      * @throws {Error} If parameters are invalid or missing
      */
-    async compute(holon, lens, options) {
+    async compute(holon, lens, options, password = null) {
         // Validate required parameters
         if (!holon || !lens) {
             throw new Error('compute: Missing required parameters');
@@ -1187,7 +1382,7 @@ class HoloSphere {
 
         // Collect all content from siblings
         const contents = await Promise.all(
-            siblings.map(sibling => this.getAll(sibling, lens))
+            siblings.map(sibling => this.getAll(sibling, lens, password))
         );
 
         const flatContents = contents.flat().filter(Boolean);
@@ -1249,7 +1444,7 @@ class HoloSphere {
                         result.value = computed;
                     }
 
-                    await this.put(parent, lens, result);
+                    await this.put(parent, lens, result, password);
                     return result;
                 }
             } catch (error) {
@@ -1296,27 +1491,52 @@ class HoloSphere {
     }
 
     /**
-     * Upcasts content to parent holonagons recursively.
+     * Upcasts content to parent holonagons recursively using federation and soul references.
+     * This is the modern implementation that uses federation references instead of duplicating data.
      * @param {string} holon - The current holon identifier.
      * @param {string} lens - The lens under which to upcast.
      * @param {object} content - The content to upcast.
-     * @returns {Promise<object>} - The upcasted content.
+     * @param {number} [maxLevels=15] - Maximum levels to upcast.
+     * @returns {Promise<object>} - The original content.
      */
-    async upcast(holon, lens, content) {
-        let res = h3.getResolution(holon)
-        if (res == 0) {
-            await this.put(holon, lens, content)
-            return content
+    async upcast(holon, lens, content, maxLevels = 15) {
+        // Store the actual content at the original resolution
+        await this.put(holon, lens, content);
+        
+        let res = h3.getResolution(holon);
+        
+        // If already at the highest level (res 0) or reached max levels, we're done
+        if (res === 0 || maxLevels <= 0) {
+            return content;
         }
-        else {
-            console.log('Upcasting ', holon, lens, content, res)
-            await this.put(holon, lens, content)
-            let parent = h3.cellToParent(holon, res - 1)
-            return this.upcast(parent, lens, content)
+        
+        // Get the parent cell
+        let parent = h3.cellToParent(holon, res - 1);
+        
+        // Create federation relationship if it doesn't exist
+        await this.federate(holon, parent);
+        
+        // Create a soul reference to store in the parent
+        const soul = `${this.appname}/${holon}/${lens}/${content.id}`;
+        const reference = {
+            id: content.id,
+            soul: soul
+        };
+        
+        // Store the reference in the parent cell
+        // We use { autoPropagate: false } to prevent circular propagation
+        await this.put(parent, lens, reference, null, { 
+            autoPropagate: false 
+        });
+        
+        // Continue upcasting with the parent
+        if (res > 1 && maxLevels > 1) {
+            return this.upcast(parent, lens, reference, maxLevels - 1);
         }
+        
+        return content;
     }
 
-
     /**
      * Updates the parent holon with a new report.
      * @param {string} id - The child holon identifier.
@@ -1384,35 +1604,88 @@ class HoloSphere {
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens to subscribe to.
      * @param {function} callback - The callback to execute on changes.
+     * @returns {Promise<object>} - Subscription object with unsubscribe method
      */
     async subscribe(holon, lens, callback) {
+        if (!holon || !lens || typeof callback !== 'function') {
+            throw new Error('subscribe: Missing required parameters');
+        }
+
         const subscriptionId = this.generateId();
-        this.subscriptions[subscriptionId] =
-            this.gun.get(this.appname).get(holon).get(lens).map().on( async (data, key) => {
+        
+        try {
+            // Create the subscription
+            const gunSubscription = this.gun.get(this.appname).get(holon).get(lens).map().on(async (data, key) => {
                 if (data) {
                     try {
-                        let parsed = await this.parse(data)
-                        callback(parsed, key)
+                        let parsed = await this.parse(data);
+                        callback(parsed, key);
                     } catch (error) {
                         console.error('Error in subscribe:', error);
                     }
                 }
-            })
-        return {
-            unsubscribe: () => {
-                this.gun.get(this.appname).get(holon).get(lens).map().off()
-                delete this.subscriptions[subscriptionId];
-            }
+            });
+            
+            // Store the subscription with its ID
+            this.subscriptions[subscriptionId] = {
+                id: subscriptionId,
+                holon,
+                lens,
+                active: true,
+                gunSubscription
+            };
+            
+            // Return an object with unsubscribe method
+            return {
+                unsubscribe: () => {
+                    try {
+                        // Turn off the Gun subscription
+                        this.gun.get(this.appname).get(holon).get(lens).map().off();
+                        
+                        // Mark as inactive and remove from subscriptions
+                        if (this.subscriptions[subscriptionId]) {
+                            this.subscriptions[subscriptionId].active = false;
+                            delete this.subscriptions[subscriptionId];
+                        }
+                    } catch (error) {
+                        console.error('Error in unsubscribe:', error);
+                    }
+                }
+            };
+        } catch (error) {
+            console.error('Error creating subscription:', error);
+            throw error;
         }
     }
 
 
+    /**
+     * Notifies subscribers about data changes
+     * @param {object} data - The data to notify about
+     * @private
+     */
     notifySubscribers(data) {
-        Object.values(this.subscriptions).forEach(subscription => {
-            if (subscription.active && this.matchesQuery(data, subscription.query)) {
-                subscription.callback(data);
-            }
-        });
+        if (!data || !data.holon || !data.lens) {
+            return;
+        }
+        
+        try {
+            Object.values(this.subscriptions).forEach(subscription => {
+                if (subscription.active && 
+                    subscription.holon === data.holon && 
+                    subscription.lens === data.lens) {
+                    try {
+                        if (subscription.callback && typeof subscription.callback === 'function') {
+                            subscription.callback(data);
+                        }
+                    } catch (error) {
+                        console.warn('Error in subscription callback:', error);
+                    }
+                }
+            });
+        } catch (error) {
+            console.warn('Error notifying subscribers:', error);
+        }
     }
 
     // Add ID generation method
@@ -1420,407 +1693,219 @@ class HoloSphere {
         return Date.now().toString(10) + Math.random().toString(2);
     }
 
-    matchesQuery(data, query) {
-        return data && query &&
-            data.holon === query.holon &&
-            data.lens === query.lens;
-    }
+    // ================================ FEDERATION FUNCTIONS ================================
 
     /**
-     * Creates a new space with the given credentials
-     * @param {string} spacename - The space identifier/username
-     * @param {string} password - The space password
-     * @returns {Promise<boolean>} - True if space was created successfully
+     * Creates a federation relationship between two holons
+     * @param {string} holonId1 - The first holon ID
+     * @param {string} holonId2 - The second holon ID
+     * @param {string} password1 - Password for the first holon
+     * @param {string} [password2] - Optional password for the second holon
+     * @param {boolean} [bidirectional=true] - Whether to set up bidirectional notifications automatically
+     * @returns {Promise<boolean>} - True if federation was created successfully
      */
-    async createSpace(spacename, password) {
-        if (!spacename || !password) {
-            throw new Error('Invalid credentials format');
-        }
-
-        // Check if space already exists
-        const existingSpace = await this.getGlobal('spaces', spacename);
-        if (existingSpace) {
-            throw new Error('Space already exists');
-        }
-
-        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);
-            const auth = {
-                salt: salt,
-                hash: hash,
-                pub: pair.pub
-            };
-
-            // Create space record with encrypted data
-            const space = {
-                alias: spacename,
-                auth: auth,
-                epub: pair.epub,
-                pub: pair.pub,
-                created: Date.now()
-            };
-
-            await this.putGlobal('spaces', {
-                ...space,
-                id: spacename
-            });
-
-            return true;
-        } catch (error) {
-            throw new Error(`Space creation failed: ${error.message}`);
-        }
+    async federate(holonId1, holonId2, password1, password2 = null, bidirectional = true) {
+        return Federation.federate(this, holonId1, holonId2, password1, password2, bidirectional);
     }
 
     /**
-     * Logs in to a space with the given credentials
-     * @param {string} spacename - The space identifier/username
-     * @param {string} password - The space password
-     * @returns {Promise<boolean>} - True if login was successful
+     * Subscribes to federation notifications for a holon
+     * @param {string} holonId - The holon ID to subscribe to
+     * @param {string} password - Password for the holon
+     * @param {function} callback - The callback to execute on notifications
+     * @param {object} [options] - Subscription options
+     * @param {string[]} [options.lenses] - Specific lenses to subscribe to (default: all)
+     * @param {number} [options.throttle] - Throttle notifications in ms (default: 0)
+     * @returns {Promise<object>} - Subscription object with unsubscribe() method
      */
-    async login(spacename, password) {
-        // Validate input
-        if (!spacename || !password ||
-            typeof spacename !== 'string' ||
-            typeof password !== 'string') {
-            throw new Error('Invalid credentials format');
-        }
-
-        try {
-            // Get space record
-            const space = await this.getGlobal('spaces', spacename);
-            if (!space || !space.auth) {
-                throw new Error('Invalid spacename or password');
-            }
-
-            // Verify password using SEA
-            const hash = await Gun.SEA.work(password, space.auth.salt);
-            if (hash !== space.auth.hash) {
-                throw new Error('Invalid spacename or password');
-            }
-
-            // Set current space with expiration
-            this.currentSpace = {
-                ...space,
-                exp: Date.now() + (24 * 60 * 60 * 1000) // 24 hour expiration
-            };
-
-            return true;
-        } catch (error) {
-            throw new Error('Authentication failed');
-        }
+    async subscribeFederation(holonId, password, callback, options = {}) {
+        return Federation.subscribeFederation(this, holonId, password, callback, options);
     }
 
     /**
-     * Logs out the current space
-     * @returns {Promise<void>}
+     * Gets federation info for a holon
+     * @param {string} holonId - The holon ID
+     * @param {string} [password] - Optional password for the holon
+     * @returns {Promise<object|null>} - Federation info or null if not found
      */
-    async logout() {
-        this.currentSpace = null;
+    async getFederation(holonId, password = null) {
+        return Federation.getFederation(this, holonId, password);
     }
 
     /**
-     * Checks if the current session is valid
-     * @private
+     * Removes a federation relationship between holons
+     * @param {string} holonId1 - The first holon ID
+     * @param {string} holonId2 - The second holon ID
+     * @param {string} password1 - Password for the first holon
+     * @param {string} [password2] - Optional password for the second holon
+     * @returns {Promise<boolean>} - True if federation was removed successfully
      */
-    _checkSession() {
-        if (!this.currentSpace) {
-            throw new Error('No active session');
-        }
-        if (this.currentSpace.exp < Date.now()) {
-            this.currentSpace = null;
-            throw new Error('Session expired');
-        }
-        return true;
+    async unfederate(holonId1, holonId2, password1, password2 = null) {
+        return await Federation.unfederate(this, holonId1, holonId2, password1, password2);
     }
 
     /**
-     * Creates a federation relationship between two spaces
-     * @param {string} spaceId1 - The first space ID
-     * @param {string} spaceId2 - The second space ID
-     * @returns {Promise<boolean>} - True if federation was created successfully
+     * Removes a notification relationship between two spaces
+     * This removes spaceId2 from the notify list of spaceId1
+     * 
+     * @param {string} holonId1 - The space to modify (remove from its notify list)
+     * @param {string} holonId2 - The space to be removed from notifications
+     * @param {string} [password1] - Optional password for the first space
+     * @returns {Promise<boolean>} - True if notification was removed successfully
      */
-    async federate(spaceId1, spaceId2) {
-        if (!spaceId1 || !spaceId2) {
-            throw new Error('federate: Missing required parameters');
-        }
-
-        // Get existing federation info for both spaces
-        let fedInfo1 = await this.getGlobal('federation', spaceId1);
-        let fedInfo2 = await this.getGlobal('federation', spaceId2);
-
-        // Check if federation already exists
-        if (fedInfo1 && fedInfo1.federation && fedInfo1.federation.includes(spaceId2)) {
-            throw new Error('Federation already exists');
-        }
-
-        // Create or update federation info for first space
-        if (!fedInfo1) {
-            fedInfo1 = {
-                id: spaceId1,
-                name: spaceId1,
-                federation: [],
-                notify: []
-            };
-        }
-        if (!fedInfo1.federation) fedInfo1.federation = [];
-        fedInfo1.federation.push(spaceId2);
-
-        // Create or update federation info for second space
-        if (!fedInfo2) {
-            fedInfo2 = {
-                id: spaceId2,
-                name: spaceId2,
-                federation: [],
-                notify: []
-            };
+    async removeNotify(holonId1, holonId2, password1 = null) {
+        console.log(`HoloSphere.removeNotify called: ${holonId1}, ${holonId2}`);
+        try {
+            const result = await Federation.removeNotify(this, holonId1, holonId2, password1);
+            console.log(`HoloSphere.removeNotify completed successfully: ${result}`);
+            return result;
+        } catch (error) {
+            console.error(`HoloSphere.removeNotify failed:`, error);
+            throw error;
         }
-        if (!fedInfo2.notify) fedInfo2.notify = [];
-        fedInfo2.notify.push(spaceId1);
-
-        // Save both federation records
-        await this.putGlobal('federation', fedInfo1);
-        await this.putGlobal('federation', fedInfo2);
-
-        return true;
     }
 
     /**
-     * Subscribes to federation notifications for a space
-     * @param {string} spaceId - The space ID to subscribe to
-     * @param {function} callback - The callback to execute on notifications
-     * @returns {Promise<object>} - Subscription object with off() method
+     * Get and aggregate data from federated holons
+     * @param {string} holon The holon name
+     * @param {string} lens The lens name
+     * @param {Object} options Options for retrieval and aggregation
+     * @returns {Promise<Array>} Combined array of local and federated data
      */
-    async subscribeFederation(spaceId, callback) {
-        if (!spaceId || !callback) {
-            throw new Error('subscribeFederation: Missing required parameters');
-        }
-
-        // Get federation info
-        const fedInfo = await this.getGlobal('federation', spaceId);
-        if (!fedInfo) {
-            throw new Error('No federation info found for space');
-        }
-
-        // Create subscription for each federated space
-        const subscriptions = [];
-        if (fedInfo.federation && fedInfo.federation.length > 0) {
-            for (const federatedSpace of fedInfo.federation) {
-                // Subscribe to all lenses in the federated space
-                const sub = await this.subscribe(federatedSpace, '*', async (data) => {
-                    try {
-                        // Only notify if the data has federation info and is from the federated space
-                        if (data && data.federation && data.federation.origin === federatedSpace) {
-                            await callback(data);
-                        }
-                    } catch (error) {
-                        console.warn('Federation notification error:', error);
-                    }
-                });
-                subscriptions.push(sub);
-            }
-        }
-
-        // Return combined subscription object
-        return {
-            off: () => {
-                subscriptions.forEach(sub => {
-                    if (sub && typeof sub.off === 'function') {
-                        sub.off();
-                    }
-                });
-            }
-        };
+    async getFederated(holon, lens, options = {}) {
+        return Federation.getFederated(this, holon, lens, options);
     }
 
     /**
-     * Gets federation info for a space
-     * @param {string} spaceId - The space ID
-     * @returns {Promise<object|null>} - Federation info or null if not found
+     * Tracks a federated message across different chats
+     * @param {string} originalChatId - The ID of the original chat
+     * @param {string} messageId - The ID of the original message
+     * @param {string} federatedChatId - The ID of the federated chat
+     * @param {string} federatedMessageId - The ID of the message in the federated chat
+     * @param {string} type - The type of message (e.g., 'quest', 'announcement')
+     * @returns {Promise<void>}
      */
-    async getFederation(spaceId) {
-        if (!spaceId) {
-            throw new Error('getFederationInfo: Missing space ID');
-        }
-        return await this.getGlobal('federation', spaceId);
+    async federateMessage(originalChatId, messageId, federatedChatId, federatedMessageId, type = 'generic') {
+        return Federation.federateMessage(this, originalChatId, messageId, federatedChatId, federatedMessageId, type);
     }
 
     /**
-     * Removes a federation relationship between spaces
-     * @param {string} spaceId1 - The first space ID
-     * @param {string} spaceId2 - The second space ID
-     * @returns {Promise<boolean>} - True if federation was removed successfully
+     * Gets all federated messages for a given original message
+     * @param {string} originalChatId - The ID of the original chat
+     * @param {string} messageId - The ID of the original message
+     * @returns {Promise<Object|null>} The tracking information for the message
      */
-    async unfederate(spaceId1, spaceId2) {
-        if (!spaceId1 || !spaceId2) {
-            throw new Error('unfederate: Missing required parameters');
-        }
-
-        // Get federation info for both spaces
-        const fedInfo1 = await this.getGlobal('federation', spaceId1);
-        const fedInfo2 = await this.getGlobal('federation', spaceId2);
-
-        if (fedInfo1) {
-            fedInfo1.federation = fedInfo1.federation.filter(id => id !== spaceId2);
-            await this.putGlobal('federation', fedInfo1);
-        }
-
-        if (fedInfo2) {
-            fedInfo2.notify = fedInfo2.notify.filter(id => id !== spaceId1);
-            await this.putGlobal('federation', fedInfo2);
-        }
-
-        return true;
+    async getFederatedMessages(originalChatId, messageId) {
+        return Federation.getFederatedMessages(this, originalChatId, messageId);
     }
 
     /**
-     * Gets the name of a chat/space
-     * @param {string} spaceId - The space ID
-     * @returns {Promise<string>} - The space name or the ID if not found
+     * Updates a federated message across all federated chats
+     * @param {string} originalChatId - The ID of the original chat
+     * @param {string} messageId - The ID of the original message
+     * @param {Function} updateCallback - Function to update the message in each chat
+     * @returns {Promise<void>}
      */
-    async getChatName(spaceId) {
-        const spaceInfo = await this.getGlobal('spaces', spaceId);
-        return spaceInfo?.name || spaceId;
+    async updateFederatedMessages(originalChatId, messageId, updateCallback) {
+        return Federation.updateFederatedMessages(this, originalChatId, messageId, updateCallback);
     }
 
     /**
-     * Gets data from a holon and lens, including data from federated spaces with optional aggregation
-     * @param {string} holon - The holon identifier
-     * @param {string} lens - The lens identifier
-     * @param {object} options - Options for data retrieval and aggregation
-     * @param {boolean} options.aggregate - Whether to aggregate items with matching IDs (default: false)
-     * @param {string} options.idField - Field to use as identifier for aggregation (default: 'id')
-     * @param {string[]} options.sumFields - Numeric fields to sum during aggregation (e.g., ['received', 'sent'])
-     * @param {string[]} options.concatArrays - Array fields to concatenate during aggregation (e.g., ['wants', 'offers'])
-     * @param {boolean} options.removeDuplicates - Whether to remove duplicates when not aggregating (default: true)
-     * @param {function} options.mergeStrategy - Custom function to merge items during aggregation
-     * @returns {Promise<Array>} - Combined array of local and federated data
+     * Resets the federation settings for a holon
+     * @param {string} holonId - The holon ID
+     * @param {string} [password] - Optional password for the holon
+     * @returns {Promise<boolean>} - True if federation was reset successfully
      */
-    async getFederated(holon, lens, options = {}) {
-        // Validate required parameters
-        if (!holon || !lens) {
-            throw new Error('getFederated: Missing required parameters');
-        }
-
-        const {
-            aggregate = false,
-            idField = 'id',
-            sumFields = [],
-            concatArrays = [],
-            removeDuplicates = true,
-            mergeStrategy = null
-        } = options;
-
-        // 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;
-        }
-
-        // Get data from each federated space
-        const federatedData = await Promise.all(
-            fedInfo.federation.map(async (federatedSpace) => {
-                try {
-                    const data = await this.getAll(federatedSpace, lens);
-                    return data || [];
-                } catch (error) {
-                    console.warn(`Error getting data from federated space ${federatedSpace}:`, error);
-                    return [];
-                }
-            })
-        );
-
-        // Combine all data
-        const allData = [...localData, ...federatedData.flat()];
-
-        // If aggregating, use enhanced aggregation logic
-        if (aggregate) {
-            const aggregated = new Map();
-
-            for (const item of allData) {
-                const itemId = item[idField];
-                if (!itemId) continue;
-
-                const existing = aggregated.get(itemId);
-                if (!existing) {
-                    aggregated.set(itemId, { ...item });
-                } else {
-                    // If custom merge strategy is provided, use it
-                    if (mergeStrategy && typeof mergeStrategy === 'function') {
-                        aggregated.set(itemId, mergeStrategy(existing, item));
-                        continue;
-                    }
-
-                    // Enhanced default merge strategy
-                    const merged = { ...existing };
+    async resetFederation(holonId, password = null) {
+        return Federation.resetFederation(this, holonId, password);
+    }
 
-                    // Sum numeric fields
-                    for (const field of sumFields) {
-                        if (typeof item[field] === 'number') {
-                            merged[field] = (merged[field] || 0) + (item[field] || 0);
+    // ================================ END FEDERATION FUNCTIONS ================================
+    /**
+     * Closes the HoloSphere instance and cleans up resources.
+     * @returns {Promise<void>}
+     */
+    async close() {
+        try {
+            if (this.gun) {
+                // Unsubscribe from all subscriptions
+                const subscriptionIds = Object.keys(this.subscriptions);
+                for (const id of subscriptionIds) {
+                    try {
+                        const subscription = this.subscriptions[id];
+                        if (subscription && subscription.active) {
+                            // Turn off the Gun subscription
+                            this.gun.get(this.appname)
+                                .get(subscription.holon)
+                                .get(subscription.lens)
+                                .map().off();
+                            
+                            // Mark as inactive
+                            subscription.active = false;
                         }
+                    } catch (error) {
+                        console.warn(`Error cleaning up subscription ${id}:`, error);
                     }
+                }
 
-                    // Concatenate and deduplicate array fields
-                    for (const field of concatArrays) {
-                        if (Array.isArray(item[field])) {
-                            const combinedArray = [
-                                ...(merged[field] || []),
-                                ...(item[field] || [])
-                            ];
-                            // Remove duplicates if elements are primitive
-                            merged[field] = Array.from(new Set(combinedArray));
+                // Clear subscriptions
+                this.subscriptions = {};
+
+                // Close Gun connections
+                if (this.gun.back) {
+                    try {
+                        const mesh = this.gun.back('opt.mesh');
+                        if (mesh && mesh.hear) {
+                            try {
+                                // Safely clear mesh.hear without modifying function properties
+                                const hearKeys = Object.keys(mesh.hear);
+                                for (const key of hearKeys) {
+                                    // Check if it's an array before trying to clear it
+                                    if (Array.isArray(mesh.hear[key])) {
+                                        mesh.hear[key] = [];
+                                    }
+                                }
+                                
+                                // Create a new empty object for mesh.hear
+                                // Only if mesh.hear is not a function
+                                if (typeof mesh.hear !== 'function') {
+                                    mesh.hear = {};
+                                }
+                            } catch (meshError) {
+                                console.warn('Error cleaning up Gun mesh hear:', meshError);
+                            }
                         }
+                    } catch (error) {
+                        console.warn('Error accessing Gun mesh:', error);
                     }
+                }
 
-                    // Update federation metadata
-                    merged.federation = {
-                        ...merged.federation,
-                        timestamp: Math.max(
-                            merged.federation?.timestamp || 0,
-                            item.federation?.timestamp || 0
-                        ),
-                        origins: Array.from(new Set([
-                            ...(merged.federation?.origins || [merged.federation?.origin]),
-                            ...(item.federation?.origins || [item.federation?.origin])
-                        ]).filter(Boolean))
-                    };
-
-                    // Update the aggregated item
-                    aggregated.set(itemId, merged);
+                // Clear all Gun instance listeners
+                try {
+                    this.gun.off();
+                } catch (error) {
+                    console.warn('Error turning off Gun listeners:', error);
                 }
+                
+                // Wait a moment for cleanup to complete
+                await new Promise(resolve => setTimeout(resolve, 100));
             }
-
-            return Array.from(aggregated.values());
-        }
-
-        // If not aggregating, optionally remove duplicates based on idField
-        if (!removeDuplicates) {
-            return allData;
+            
+            console.log('HoloSphere instance closed successfully');
+        } catch (error) {
+            console.error('Error closing HoloSphere instance:', error);
         }
+    }
 
-        // 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 ||
-                (item.federation?.timestamp > (existing.federation?.timestamp || 0))) {
-                uniqueMap.set(id, item);
-            }
-        });
-        return Array.from(uniqueMap.values());
+    /**
+     * Creates a namespaced username for Gun authentication
+     * @private
+     * @param {string} holonId - The holon ID
+     * @returns {string} - Namespaced username
+     */
+    userName(holonId) {
+        if (!holonId) return null;
+        return `${this.appname}:${holonId}`;
     }
 }