holosphere 1.1.4 → 1.1.6

package/holosphere.js

@@ -3,6 +3,7 @@ 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';
 
 
 class HoloSphere {
@@ -14,6 +15,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.6'); 
         this.appname = appname
         this.strict = strict;
         this.validator = new Ajv2019({
@@ -22,14 +24,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', 'https://59.src.eco/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;
@@ -40,9 +45,6 @@ class HoloSphere {
             });
         }
 
-        // Add currentSpace property to track logged in space
-        this.currentSpace = null;
-
         // Initialize subscriptions
         this.subscriptions = {};
     }
@@ -65,68 +67,49 @@ class HoloSphere {
             throw new Error('setSchema: Schema must have a type field');
         }
 
-        if (this.strict) {
-            const metaSchema = {
-                type: 'object',
-                required: ['type', 'properties'],
+        const metaSchema = {
+            type: 'object',
+            required: ['type', 'properties'],
+            properties: {
+                type: { type: 'string' },
                 properties: {
-                    type: { type: 'string' },
-                    properties: {
+                    type: 'object',
+                    additionalProperties: {
                         type: 'object',
-                        additionalProperties: {
-                            type: 'object',
-                            required: ['type'],
-                            properties: {
-                                type: { type: 'string' }
-                            }
+                        required: ['type'],
+                        properties: {
+                            type: { type: 'string' }
                         }
-                    },
-                    required: {
-                        type: 'array',
-                        items: { type: 'string' }
                     }
+                },
+                required: {
+                    type: 'array',
+                    items: { type: 'string' }
                 }
-            };
-
-            const valid = this.validator.validate(metaSchema, schema);
-            if (!valid) {
-                throw new Error(`Invalid schema structure: ${JSON.stringify(this.validator.errors)}`);
-            }
-
-            if (!schema.properties || typeof schema.properties !== 'object') {
-                throw new Error('Schema must have properties in strict mode');
             }
+        };
 
-            if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
-                throw new Error('Schema must have required fields in strict mode');
-            }
+        const valid = this.validator.validate(metaSchema, schema);
+        if (!valid) {
+            throw new Error(`Invalid schema structure: ${JSON.stringify(this.validator.errors)}`);
         }
 
-        return new Promise((resolve, reject) => {
-            try {
-                const schemaString = JSON.stringify(schema);
-                const schemaData = {
-                    schema: schemaString,
-                    timestamp: Date.now(),
-                    // Only set owner if there's an authenticated space
-                    ...(this.currentSpace && { owner: this.currentSpace.alias })
-                };
+        if (!schema.properties || typeof schema.properties !== 'object') {
+            throw new Error('Schema must have properties in strict mode');
+        }
 
-                this.gun.get(this.appname)
-                    .get(lens)
-                    .get('schema')
-                    .put(schemaData, ack => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            // Add small delay to ensure data is written
-                            setTimeout(() => resolve(true), 50);
-                        }
-                    });
-            } catch (error) {
-                reject(error);
-            }
+        if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
+            throw new Error('Schema must have required fields in strict mode');
+        }
+        
+        // Store schema in global table with lens as key
+        await this.putGlobal('schemas', {
+            id: lens,
+            schema: schema,
+            timestamp: Date.now()
         });
+
+        return true;
     }
 
     /**
@@ -139,39 +122,12 @@ class HoloSphere {
             throw new Error('getSchema: Missing lens parameter');
         }
 
-        return new Promise((resolve) => {
-            let timeout = setTimeout(() => {
-                console.warn('getSchema: Operation timed out');
-                resolve(null);
-            }, 5000);
-
-            this.gun.get(this.appname)
-                .get(lens)
-                .get('schema')
-                .once(data => {
-                    clearTimeout(timeout);
-                    if (!data) {
-                        resolve(null);
-                        return;
-                    }
+        const schemaData = await this.getGlobal('schemas', lens);
+        if (!schemaData || !schemaData.schema) {
+            return null;
+        }
 
-                    try {
-                        // Handle both new format and legacy format
-                        if (data.schema) {
-                            // New format with timestamp
-                            resolve(JSON.parse(data.schema));
-                        } else {
-                            // Legacy format or direct string
-                            const schemaStr = typeof data === 'string' ? data :
-                                Object.values(data).find(v => typeof v === 'string' && v.includes('"type":'));
-                            resolve(schemaStr ? JSON.parse(schemaStr) : null);
-                        }
-                    } catch (error) {
-                        console.error('getSchema: Error parsing schema:', error);
-                        resolve(null);
-                    }
-                });
-        });
+        return schemaData.schema;
     }
 
     // ================================ CONTENT FUNCTIONS ================================
@@ -181,148 +137,142 @@ 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 space.
      * @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) {
+    async put(holon, lens, data, password = null) {
+        if (!holon || !lens || !data) {
             throw new Error('put: Missing required parameters');
         }
 
-        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 => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            // Notify subscribers after successful put
-                            this.notifySubscribers({
-                                holon,
-                                lens,
-                                ...dataWithMeta
+        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();
+                                    });
+                                }
                             });
-                            resolve(true);
+                        });
+                    } 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');
                         }
-                    });
-            } catch (error) {
-                reject(error);
-            }
-        });
-
-        // If successful, propagate to federated spaces
-        if (putResult) {
-            await this._propagateToFederation(holon, lens, dataWithMeta);
-        }
-
-        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
-     */
-    async _propagateToFederation(holon, lens, data) {
-        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
+                    }
+                }
             }
 
-            // 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()
-                            }
-                        }), ack => {
+            return new Promise((resolve, reject) => {
+                try {
+                    const payload = JSON.stringify(data);
+                    
+                    if (password) {
+                        // For private data, use the authenticated user's space
+                        user.get('private').get(lens).get(data.id).put(payload, ack => {
                             if (ack.err) {
-                                console.warn(`Failed to propagate to space ${spaceId}:`, ack.err);
+                                reject(new Error(ack.err));
+                            } else {
+                                this.notifySubscribers({
+                                    holon,
+                                    lens,
+                                    ...data
+                                });
+                                resolve(true);
                             }
-                            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()
+                    } else {
+                        // For public data, use the regular path
+                        this.gun.get(this.appname).get(holon).get(lens).get(data.id).put(payload, ack => {
+                            if (ack.err) {
+                                reject(new Error(ack.err));
+                            } else {
+                                this.notifySubscribers({
+                                    holon,
+                                    lens,
+                                    ...data
+                                });
+                                resolve(true);
                             }
-                        }));
-                })
-            );
-
-            await Promise.all(propagationPromises);
+                        });
+                    }
+                } catch (error) {
+                    reject(error);
+                }
+            });
         } catch (error) {
-            console.warn('Federation propagation error:', error);
-            // Don't throw here to avoid failing the original put
+            console.error('Error in put:', error);
+            throw error;
         }
     }
 
@@ -330,151 +280,160 @@ class HoloSphere {
      * 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.
+     * @param {string} key - The specific key to retrieve.
+     * @param {string} [password] - Optional password for private space.
+     * @returns {Promise<object|null>} - The retrieved content or null if not found.
      */
-    async getAll(holon, lens) {
-        if (!holon || !lens) {
-            throw new Error('getAll: Missing required parameters');
-        }
-
-        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);
+    async get(holon, lens, key, password = null) {
+        if (!holon || !lens || !key) {
+            console.error('get: Missing required parameters:', { holon, lens, key });
+            return null;
         }
 
-        // 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);
+        // 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');
             }
-        });
+        }
 
-        // 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);
+        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
+                    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();
+                                });
+                            }
+                        });
+                    });
                 }
             }
-        });
 
-        return Array.from(combined.values());
-    }
+            return new Promise((resolve) => {
+                const handleData = async (data) => {
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
 
-    /**
-     * Gets data from federated spaces
-     * @private
-     * @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
-     */
-    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 {
+                        const parsed = await this.parse(data);
 
-            // 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 (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;
+                                }
                             }
-                        });
-                });
+                        }
 
-                if (result) {
-                    return result;
+                        resolve(parsed);
+                    } catch (error) {
+                        console.error('Error parsing data:', error);
+                        resolve(null);
+                    }
+                };
+
+                if (password) {
+                    // For private data, use the authenticated user's space
+                    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 get error:', error);
+            console.error('Error in get:', error);
+            return null;
         }
-        return null;
     }
 
     /**
-     * Gets all data from local space
-     * @private
+     * Propagates data to federated spaces
      * @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
+     * @param {object} data - The data to propagate
+     * @param {object} [options] - Propagation options
+     * @returns {Promise<object>} - Result with success count and errors
      */
-    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 propagateToFederation(holon, lens, data, options = {}) {
+        return Federation.propagateToFederation(this, holon, lens, data, options);
+    }
 
-            const processData = async (data, key) => {
-                if (!data || key === '_') return;
+    /**
+     * @private
+     * @deprecated Use propagateToFederation instead
+     */
+    async _propagateToFederation(holon, lens, data) {
+        console.warn('_propagateToFederation is deprecated, use propagateToFederation instead');
+        return this.propagateToFederation(holon, lens, data);
+    }
 
-                try {
-                    const parsed = await this.parse(data);
-                    if (!parsed || !parsed.id) return;
+    /**
+     * 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 space.
+     * @returns {Promise<Array<object>>} - The retrieved content.
+     */
+    async getAll(holon, lens, password = null) {
+        if (!holon || !lens) {
+            throw new Error('getAll: Missing required parameters');
+        }
+
+        const schema = await this.getSchema(lens);
+        if (!schema && this.strict) {
+            throw new Error('getAll: Schema required in strict mode');
+        }
+
+        try {
+            const user = this.gun.user();
+
+            return new Promise((resolve) => {
+                const output = new Map();
+
+                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) {
+                        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;
                     }
@@ -488,75 +447,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 space
+                    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 [];
         }
     }
@@ -567,11 +474,19 @@ class HoloSphere {
    * @returns {Promise<object>} - The parsed data.
    */
     async parse(rawData) {
+        let parsedData = {};
+
         if (!rawData) {
             throw new Error('parse: No data provided');
         }
 
         try {
+
+            if (typeof rawData === 'string') {
+                parsedData = await JSON.parse(rawData);
+            }
+
+
             if (rawData.soul) {
                 const data = await this.getNodeRef(rawData.soul).once();
                 if (!data) {
@@ -580,7 +495,7 @@ class HoloSphere {
                 return JSON.parse(data);
             }
 
-            let parsedData = {};
+       
             if (typeof rawData === 'object' && rawData !== null) {
                 if (rawData._ && rawData._["#"]) {
                     const pathParts = rawData._['#'].split('/');
@@ -600,11 +515,10 @@ class HoloSphere {
                 } else {
                     parsedData = rawData;
                 }
-            } else {
-                parsedData = JSON.parse(rawData);
             }
 
             return parsedData;
+
         } catch (error) {
             console.log("Parsing not a JSON, returning raw data", rawData);
             return rawData;
@@ -612,186 +526,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 space.
+     * @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 space
+            const user = this.gun.user();
+
+            // Delete data from space
+            return new Promise((resolve, reject) => {
+                if (password) {
+                    // For private data, use the authenticated user's space
+                    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 space.
+     * @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 space
+            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 ================================
@@ -908,243 +752,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 space.
      * @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 space
+                    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 space.
+     * @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 space
+                    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 space.
+     * @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 space
+            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;
+                    }
+
+                    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);
+                    }
+                };
 
-                        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);
+                if (password) {
+                    // For private data, use the authenticated user's space
+                    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 space.
+     * @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 space
+            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 space
+                    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 space.
+     * @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 space
+            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 spaces
+     */
+    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);
                 }
@@ -1160,16 +1179,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 spaces
      * @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');
@@ -1224,7 +1245,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);
@@ -1286,7 +1307,7 @@ class HoloSphere {
                         result.value = computed;
                     }
 
-                    await this.put(parent, lens, result);
+                    await this.put(parent, lens, result, password);
                     return result;
                 }
             } catch (error) {
@@ -1421,307 +1442,143 @@ 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) {
-        const subscriptionId = this.generateSubscriptionId();
-        this.subscriptions[subscriptionId] = {
-            query: { holon, lens },
-            callback,
-            active: true
-        };
-
-        // Add cleanup to ensure callback isn't called after unsubscribe
-        return {
-            unsubscribe: () => {
-                if (this.subscriptions[subscriptionId]) {
-                    delete this.subscriptions[subscriptionId];
-                }
-            }
-        };
-    }
-
-    notifySubscribers(data) {
-        Object.values(this.subscriptions).forEach(subscription => {
-            if (subscription.active && this.matchesQuery(data, subscription.query)) {
-                subscription.callback(data);
-            }
-        });
-    }
-
-    // Add ID generation method
-    generateId() {
-        return Date.now().toString(10) + Math.random().toString(2);
-    }
-
-    generateSubscriptionId() {
-        return Date.now().toString(10) + Math.random().toString(2);
-    }
-
-    matchesQuery(data, query) {
-        return data && query && 
-               data.holon === query.holon && 
-               data.lens === query.lens;
-    }
-
-    /**
-     * Creates a new space with the given credentials
-     * @param {string} spacename - The space identifier/username
-     * @param {string} password - The space password
-     * @returns {Promise<boolean>} - True if space 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');
+        if (!holon || !lens || typeof callback !== 'function') {
+            throw new Error('subscribe: Missing required parameters');
         }
 
+        const subscriptionId = this.generateId();
+        
         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 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);
+                    } catch (error) {
+                        console.error('Error in subscribe:', error);
+                    }
+                }
+            });
+            
+            // Store the subscription with its ID
+            this.subscriptions[subscriptionId] = {
+                id: subscriptionId,
+                holon,
+                lens,
+                active: true,
+                gunSubscription
             };
-
-            // Create space record with encrypted data
-            const space = {
-                alias: spacename,
-                auth: auth,
-                epub: pair.epub,
-                pub: pair.pub,
-                created: Date.now()
+            
+            // 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);
+                    }
+                }
             };
-
-            await this.putGlobal('spaces', {
-                ...space,
-                id: spacename
-            });
-
-            return true;
         } catch (error) {
-            throw new Error(`Space creation failed: ${error.message}`);
+            console.error('Error creating subscription:', error);
+            throw error;
         }
     }
 
+
     /**
-     * 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
+     * Notifies subscribers about data changes
+     * @param {object} data - The data to notify about
+     * @private
      */
-    async login(spacename, password) {
-        // Validate input
-        if (!spacename || !password ||
-            typeof spacename !== 'string' ||
-            typeof password !== 'string') {
-            throw new Error('Invalid credentials format');
+    notifySubscribers(data) {
+        if (!data || !data.holon || !data.lens) {
+            return;
         }
-
+        
         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;
+            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) {
-            throw new Error('Authentication failed');
+            console.warn('Error notifying subscribers:', error);
         }
     }
 
-    /**
-     * Logs out the current space
-     * @returns {Promise<void>}
-     */
-    async logout() {
-        this.currentSpace = null;
+    // Add ID generation method
+    generateId() {
+        return Date.now().toString(10) + Math.random().toString(2);
     }
 
-    /**
-     * Checks if the current session is valid
-     * @private
-     */
-    _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;
-    }
+    // ================================ FEDERATION FUNCTIONS ================================
 
     /**
      * Creates a federation relationship between two spaces
      * @param {string} spaceId1 - The first space ID
      * @param {string} spaceId2 - The second space ID
+     * @param {string} password1 - Password for the first space
+     * @param {string} [password2] - Optional password for the second space
      * @returns {Promise<boolean>} - True if federation was created 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: []
-            };
-        }
-        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;
+    async federate(spaceId1, spaceId2, password1, password2 = null) {
+        return Federation.federate(this, spaceId1, spaceId2, password1, password2);
     }
 
     /**
      * Subscribes to federation notifications for a space
      * @param {string} spaceId - The space ID to subscribe to
+     * @param {string} password - Password for the space
      * @param {function} callback - The callback to execute on notifications
-     * @returns {Promise<object>} - Subscription object with off() method
+     * @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 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 subscribeFederation(spaceId, password, callback, options = {}) {
+        return Federation.subscribeFederation(this, spaceId, password, callback, options);
     }
 
     /**
      * Gets federation info for a space
      * @param {string} spaceId - The space ID
+     * @param {string} [password] - Optional password for the space
      * @returns {Promise<object|null>} - Federation info or null if not found
      */
-    async getFederation(spaceId) {
-        if (!spaceId) {
-            throw new Error('getFederationInfo: Missing space ID');
-        }
-        return await this.getGlobal('federation', spaceId);
+    async getFederation(spaceId, password = null) {
+        return Federation.getFederation(this, spaceId, password);
     }
 
     /**
      * Removes a federation relationship between spaces
      * @param {string} spaceId1 - The first space ID
      * @param {string} spaceId2 - The second space ID
+     * @param {string} password1 - Password for the first space
+     * @param {string} [password2] - Optional password for the second space
      * @returns {Promise<boolean>} - True if federation was removed successfully
      */
-    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;
-    }
-
-    /**
-     * 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
-     */
-    async getChatName(spaceId) {
-        const spaceInfo = await this.getGlobal('spaces', spaceId);
-        return spaceInfo?.name || spaceId;
+    async unfederate(spaceId1, spaceId2, password1, password2 = null) {
+        return Federation.unfederate(this, spaceId1, spaceId2, password1, password2);
     }
 
     /**
@@ -1729,135 +1586,109 @@ class HoloSphere {
      * @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
+     * @param {string} [password] - Optional password for accessing private data
      * @returns {Promise<Array>} - Combined array of local and federated data
      */
-    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 getFederated(holon, lens, options = {}, password = null) {
+        return Federation.getFederated(this, holon, lens, options, password);
+    }
 
-                    // Sum numeric fields
-                    for (const field of sumFields) {
-                        if (typeof item[field] === 'number') {
-                            merged[field] = (merged[field] || 0) + (item[field] || 0);
+    /**
+     * 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);
                     }
+                }
+
+                // Clear subscriptions
+                this.subscriptions = {};
 
-                    // 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));
+                // 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;
+    /**
+     * Gets the name of a chat/space
+     * @param {string} spaceId - The space ID
+     * @param {string} [password] - Optional password for the space
+     * @returns {Promise<string>} - The space name or the ID if not found
+     */
+    async getChatName(spaceId, password = null) {
+        const spaceInfo = await this.getGlobal('spaces', spaceId, password);
+        return spaceInfo?.name || spaceId;
+    }
 
-            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} spaceId - The space ID
+     * @returns {string} - Namespaced username
+     */
+    userName(spaceId) {
+        if (!spaceId) return null;
+        return `${this.appname}:${spaceId}`;
     }
 }