holosphere 2.0.0-alpha1 → 2.0.0-alpha10

package/src/storage/backends/gundb-backend.js

@@ -1,39 +1,112 @@
 /**
- * GunDB Storage Backend
- * Wraps existing gun-wrapper.js as a StorageBackend
+ * @fileoverview GunDB storage backend with authentication, schema validation, references, and global tables.
+ * Provides full-featured P2P data storage using GunDB with write caching for immediate consistency.
+ * @module storage/backends/gundb-backend
  */
 
 import { StorageBackend } from '../backend-interface.js';
 import * as wrapper from '../gun-wrapper.js';
 import { gunPromise, gunPut, gunMap, gunCollect } from '../gun-async.js';
+import { GunReferenceHandler } from '../gun-references.js';
+import { GunAuth } from '../gun-auth.js';
+import { GunSchemaValidator } from '../gun-schema.js';
 
+/**
+ * GunDB storage backend implementation with advanced features.
+ * Supports authentication, schema validation, references, global tables,
+ * and write caching for immediate consistency.
+ *
+ * @class GunDBBackend
+ * @extends StorageBackend
+ * @example
+ * const backend = await BackendFactory.create('gundb', {
+ *   appName: 'myapp',
+ *   peers: ['wss://gun-server.example.com/gun'],
+ *   radisk: true
+ * });
+ */
 export class GunDBBackend extends StorageBackend {
+  /**
+   * Create a new GunDB backend instance.
+   * @param {Object} config - Backend configuration
+   * @param {string} [config.appName='holosphere'] - Application namespace
+   * @param {string[]} [config.peers=[]] - Array of peer URLs
+   * @param {boolean} [config.radisk=true] - Enable radisk persistence
+   * @param {boolean} [config.localStorage=true] - Enable localStorage
+   * @param {string} [config.dataDir='radata'] - Data directory for Node.js
+   * @param {string} [config.privateKey] - Optional existing private key
+   * @param {string} [config.publicKey] - Optional existing public key
+   * @param {boolean} [config.strict=false] - Enable strict schema validation
+   */
   constructor(config) {
     super(config);
     this.gun = null;
     this.keyPair = null;
+    this.appName = config.appName || 'holosphere';
+
+    // New modules
+    this.references = null;
+    this.auth = null;
+    this.schemaValidator = null;
+
+    // Subscription tracking
+    this.subscriptions = new Map();
+    this.subscriptionCounter = 0;
+
+    // Write cache for immediate consistency
+    // Gun's readAll/map().once() doesn't immediately see new writes - this cache bridges that gap
+    this.writeCache = new Map(); // path -> Map(id -> {data, timestamp})
+    this.writeCacheTTL = 300000; // Cache entries expire after 5 minutes (increased from 30s)
+
+    // Pending writes queue for retry
+    this.pendingWrites = new Map(); // path -> {data, retries, lastAttempt}
+    this.maxWriteRetries = 5;
+    this.writeRetryInterval = 10000; // 10 seconds between retries
   }
 
   async init() {
     // Dynamically import Gun to avoid issues if not installed
     let Gun;
     try {
+      console.log('[gundb-backend] Importing Gun...');
       const gunModule = await import('gun');
       Gun = gunModule.default || gunModule;
+      console.log('[gundb-backend] Gun imported:', typeof Gun);
     } catch (error) {
       throw new Error(
         'GunDB backend requires the "gun" package. Install it with: npm install gun'
       );
     }
 
+    // In Node.js, Gun needs a file path for radisk persistence
+    // Default to 'radata' if not specified
+    const dataDir = this.config.dataDir || 'radata';
+
     const gunConfig = {
       peers: this.config.peers || [],
       radisk: this.config.radisk !== false,
       localStorage: this.config.localStorage !== false,
-      file: this.config.dataDir,
+      file: dataDir,
     };
 
+    console.log('[gundb-backend] Gun config:', JSON.stringify(gunConfig));
+
     this.gun = Gun(gunConfig);
+    console.log('[gundb-backend] Gun instance created:', !!this.gun);
+
+    // Test basic Gun functionality
+    try {
+      const testKey = `_test_${Date.now()}`;
+      this.gun.get(testKey).put({ test: true }, (ack) => {
+        console.log('[gundb-backend] Gun test write ack:', ack);
+      });
+      console.log('[gundb-backend] Gun test write initiated');
+    } catch (e) {
+      console.error('[gundb-backend] Gun test write failed:', e.message);
+    }
+
+    // Add a small delay to let Gun initialize
+    await new Promise(resolve => setTimeout(resolve, 500));
 
     // Generate or use provided key pair using Gun's SEA
     try {
@@ -50,28 +123,253 @@ export class GunDBBackend extends StorageBackend {
         }
       } else {
         // SEA not available, use simple identifier
-        this.publicKey = this.config.appName || 'gundb-user';
+        this.publicKey = this.appName;
       }
     } catch (error) {
       // SEA might not be loaded
-      this.publicKey = this.config.appName || 'gundb-user';
+      this.publicKey = this.appName;
+    }
+
+    // Initialize modules
+    this.references = new GunReferenceHandler(this.appName);
+    this.auth = new GunAuth(this.gun, this.appName);
+    this.schemaValidator = new GunSchemaValidator({
+      strict: this.config.strict || false,
+      cacheMaxAge: this.config.schemaCacheMaxAge || 3600000
+    });
+
+    // Try to initialize schema validator (may fail if AJV not installed)
+    await this.schemaValidator.init();
+  }
+
+  // ============================================================================
+  // WRITE CACHE (for immediate consistency)
+  // ============================================================================
+
+  /**
+   * Add item to the local write cache for immediate consistency
+   * @private
+   */
+  _addToWriteCache(path, data) {
+    if (!data || !data.id) return;
+
+    // Extract the parent path (without the data id)
+    const parentPath = path.substring(0, path.lastIndexOf('/'));
+    if (!parentPath) return;
+
+    if (!this.writeCache.has(parentPath)) {
+      this.writeCache.set(parentPath, new Map());
+    }
+
+    const pathCache = this.writeCache.get(parentPath);
+    pathCache.set(data.id.toString(), {
+      data: data,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Remove item from write cache (e.g., on delete)
+   * @private
+   */
+  _removeFromWriteCache(path, id) {
+    // Extract the parent path
+    const parentPath = path.substring(0, path.lastIndexOf('/'));
+    const pathCache = this.writeCache.get(parentPath);
+    if (pathCache) {
+      pathCache.delete(id.toString());
+    }
+  }
+
+  /**
+   * Get cached writes for a path, filtering out expired entries
+   * @private
+   */
+  _getWriteCacheEntries(path) {
+    const pathCache = this.writeCache.get(path);
+    if (!pathCache) return [];
+
+    const now = Date.now();
+    const validEntries = [];
+
+    for (const [id, entry] of pathCache) {
+      if (now - entry.timestamp < this.writeCacheTTL) {
+        validEntries.push(entry.data);
+      } else {
+        // Clean up expired entries
+        pathCache.delete(id);
+      }
+    }
+
+    return validEntries;
+  }
+
+  /**
+   * Merge cached writes with results from Gun
+   * @private
+   */
+  _mergeWithWriteCache(path, gunResults) {
+    const cachedWrites = this._getWriteCacheEntries(path);
+    if (cachedWrites.length === 0) return gunResults;
+
+    // Create a map by ID for deduplication
+    const resultMap = new Map();
+
+    // Add Gun results first
+    for (const item of gunResults) {
+      if (item && item.id) {
+        resultMap.set(item.id.toString(), item);
+      }
+    }
+
+    // Overlay cached writes (they're more recent)
+    for (const item of cachedWrites) {
+      if (item && item.id && !item._deleted) {
+        resultMap.set(item.id.toString(), item);
+      } else if (item && item.id && item._deleted) {
+        // Remove deleted items
+        resultMap.delete(item.id.toString());
+      }
+    }
+
+    return Array.from(resultMap.values());
+  }
+
+  /**
+   * Clear write cache for a specific path or all paths
+   * @param {string} [path] - Optional path to clear, clears all if not provided
+   */
+  clearWriteCache(path = null) {
+    if (path) {
+      this.writeCache.delete(path);
+    } else {
+      this.writeCache.clear();
     }
   }
 
+  // ============================================================================
+  // PATH BUILDING
+  // ============================================================================
+
   buildPath(appName, holonId, lensName, key = null) {
     return wrapper.buildPath(appName, holonId, lensName, key);
   }
 
+  buildGlobalPath(tableName, key = null) {
+    return wrapper.buildGlobalPath(this.appName, tableName, key);
+  }
+
+  // ============================================================================
+  // BASIC CRUD OPERATIONS
+  // ============================================================================
+
   async write(path, data, options = {}) {
-    return wrapper.write(this.gun, path, data);
+    // Validate against schema if strict mode
+    if (this.schemaValidator && this.schemaValidator.isStrict()) {
+      const pathParts = path.split('/');
+      if (pathParts.length >= 3) {
+        const lens = pathParts[2];
+        // Skip validation for references
+        if (!this.isReference(data)) {
+          const result = await this.schemaValidator.validateData(
+            this.gun, this.appName, lens, data
+          );
+          if (!result.valid) {
+            throw new Error(`Schema validation failed: ${JSON.stringify(result.errors)}`);
+          }
+        }
+      }
+    }
+
+    // Add to write cache FIRST for immediate consistency
+    // This ensures readAll returns the new data even if Gun write is slow/times out
+    this._addToWriteCache(path, data);
+
+    // Try to write to Gun with retry on timeout
+    const result = await this._writeWithRetry(path, data);
+
+    return result;
+  }
+
+  /**
+   * Write to Gun with automatic retry on timeout
+   * @private
+   */
+  async _writeWithRetry(path, data, attempt = 0) {
+    const result = await wrapper.write(this.gun, path, data);
+
+    if (result.timeout && attempt < this.maxWriteRetries) {
+      // Queue for background retry
+      this.pendingWrites.set(path, {
+        data,
+        retries: attempt + 1,
+        lastAttempt: Date.now()
+      });
+
+      // Schedule retry
+      this._scheduleRetry(path);
+    } else if (!result.timeout) {
+      // Success - remove from pending
+      this.pendingWrites.delete(path);
+    }
+
+    return result;
+  }
+
+  /**
+   * Schedule a background retry for a pending write
+   * @private
+   */
+  _scheduleRetry(path) {
+    setTimeout(async () => {
+      const pending = this.pendingWrites.get(path);
+      if (!pending) return;
+
+      if (pending.retries >= this.maxWriteRetries) {
+        console.warn(`[gundb-backend] Max retries reached for: ${path}`);
+        this.pendingWrites.delete(path);
+        return;
+      }
+
+      console.log(`[gundb-backend] Retrying write (attempt ${pending.retries + 1}): ${path}`);
+      await this._writeWithRetry(path, pending.data, pending.retries);
+    }, this.writeRetryInterval);
   }
 
   async read(path, options = {}) {
-    return wrapper.read(this.gun, path);
+    const data = await wrapper.read(this.gun, path);
+
+    // Resolve references if requested
+    if (data && options.resolveReferences && this.isReference(data)) {
+      return this.resolveReference(data);
+    }
+
+    return data;
   }
 
   async readAll(path, options = {}) {
-    return wrapper.readAll(this.gun, path);
+    const gunItems = await wrapper.readAll(this.gun, path);
+
+    // Merge with write cache for immediate consistency
+    const items = this._mergeWithWriteCache(path, gunItems);
+
+    // Resolve references if requested
+    if (options.resolveReferences) {
+      const resolved = [];
+      for (const item of items) {
+        if (this.isReference(item)) {
+          const resolvedItem = await this.resolveReference(item);
+          if (resolvedItem) {
+            resolved.push(resolvedItem);
+          }
+        } else {
+          resolved.push(item);
+        }
+      }
+      return resolved;
+    }
+
+    return items;
   }
 
   async update(path, updates) {
@@ -79,11 +377,27 @@ export class GunDBBackend extends StorageBackend {
   }
 
   async delete(path) {
-    return wrapper.deleteData(this.gun, path);
+    const result = await wrapper.deleteData(this.gun, path);
+
+    // Extract id from path and mark as deleted in cache
+    const pathParts = path.split('/');
+    const id = pathParts[pathParts.length - 1];
+    if (id) {
+      // Add tombstone to cache so readAll doesn't return this item
+      const parentPath = path.substring(0, path.lastIndexOf('/'));
+      if (!this.writeCache.has(parentPath)) {
+        this.writeCache.set(parentPath, new Map());
+      }
+      this.writeCache.get(parentPath).set(id.toString(), {
+        data: { id, _deleted: true },
+        timestamp: Date.now()
+      });
+    }
+
+    return result;
   }
 
   async deleteAll(path) {
-    // Gun doesn't have a native deleteAll, so we iterate and delete
     const items = await this.readAll(path);
     let count = 0;
 
@@ -98,58 +412,343 @@ export class GunDBBackend extends StorageBackend {
     return { success: true, count };
   }
 
+  // ============================================================================
+  // GLOBAL TABLE OPERATIONS
+  // ============================================================================
+
+  async writeGlobal(tableName, data) {
+    // Add to write cache FIRST for immediate consistency
+    // This ensures readAllGlobal returns the new data even if Gun write is slow/times out
+    const path = this.buildGlobalPath(tableName, data.id);
+    this._addToWriteCache(path, data);
+
+    // Try to write to Gun with retry on timeout
+    const result = await this._writeGlobalWithRetry(tableName, data);
+
+    return result;
+  }
+
+  /**
+   * Write to global table with automatic retry on timeout
+   * @private
+   */
+  async _writeGlobalWithRetry(tableName, data, attempt = 0) {
+    const path = this.buildGlobalPath(tableName, data.id);
+    const result = await wrapper.writeGlobal(this.gun, this.appName, tableName, data);
+
+    if (result.timeout && attempt < this.maxWriteRetries) {
+      // Queue for background retry
+      this.pendingWrites.set(path, {
+        data: { tableName, data },
+        isGlobal: true,
+        retries: attempt + 1,
+        lastAttempt: Date.now()
+      });
+
+      // Schedule retry
+      this._scheduleGlobalRetry(path, tableName);
+    } else if (!result.timeout) {
+      // Success - remove from pending
+      this.pendingWrites.delete(path);
+    }
+
+    return result;
+  }
+
+  /**
+   * Schedule a background retry for a pending global write
+   * @private
+   */
+  _scheduleGlobalRetry(path, tableName) {
+    setTimeout(async () => {
+      const pending = this.pendingWrites.get(path);
+      if (!pending || !pending.isGlobal) return;
+
+      if (pending.retries >= this.maxWriteRetries) {
+        console.warn(`[gundb-backend] Max retries reached for global: ${path}`);
+        this.pendingWrites.delete(path);
+        return;
+      }
+
+      console.log(`[gundb-backend] Retrying global write (attempt ${pending.retries + 1}): ${path}`);
+      await this._writeGlobalWithRetry(tableName, pending.data.data, pending.retries);
+    }, this.writeRetryInterval);
+  }
+
+  async readGlobal(tableName, key) {
+    return wrapper.readGlobal(this.gun, this.appName, tableName, key);
+  }
+
+  async readAllGlobal(tableName, timeout = 5000) {
+    const gunItems = await wrapper.readAllGlobal(this.gun, this.appName, tableName, timeout);
+
+    // Merge with write cache for immediate consistency
+    const path = this.buildGlobalPath(tableName);
+    return this._mergeWithWriteCache(path, gunItems);
+  }
+
+  async deleteGlobal(tableName, key) {
+    const result = await wrapper.deleteGlobal(this.gun, this.appName, tableName, key);
+
+    // Mark as deleted in cache
+    const path = this.buildGlobalPath(tableName);
+    if (!this.writeCache.has(path)) {
+      this.writeCache.set(path, new Map());
+    }
+    this.writeCache.get(path).set(key.toString(), {
+      data: { id: key, _deleted: true },
+      timestamp: Date.now()
+    });
+
+    return result;
+  }
+
+  async deleteAllGlobal(tableName) {
+    return wrapper.deleteAllGlobal(this.gun, this.appName, tableName);
+  }
+
+  // ============================================================================
+  // REFERENCE OPERATIONS
+  // ============================================================================
+
+  /**
+   * Create a reference to data
+   */
+  createReference(holon, lens, data) {
+    return this.references.createReference(holon, lens, data);
+  }
+
+  /**
+   * Check if data is a reference
+   */
+  isReference(data) {
+    return this.references.isReference(data);
+  }
+
+  /**
+   * Resolve a reference to get actual data
+   */
+  async resolveReference(reference, options = {}) {
+    return this.references.resolveReference(this.gun, reference, options);
+  }
+
+  /**
+   * Parse a soul path
+   */
+  parseSoulPath(soul) {
+    return this.references.parseSoulPath(soul);
+  }
+
+  /**
+   * Get soul for data
+   */
+  getSoul(holon, lens, key) {
+    return this.references.getSoul(holon, lens, key);
+  }
+
+  // ============================================================================
+  // AUTHENTICATION OPERATIONS
+  // ============================================================================
+
+  /**
+   * Authenticate for a holon
+   */
+  async authenticate(holonId, password) {
+    return this.auth.authenticate(holonId, password);
+  }
+
+  /**
+   * Create a new user
+   */
+  async createUser(holonId, password) {
+    return this.auth.createUser(holonId, password);
+  }
+
+  /**
+   * Logout current user
+   */
+  logout() {
+    this.auth.logout();
+  }
+
+  /**
+   * Check if authenticated
+   */
+  isAuthenticated() {
+    return this.auth.isAuthenticated();
+  }
+
+  /**
+   * Write to private storage
+   */
+  async writePrivate(lens, key, data) {
+    return this.auth.writePrivate(lens, key, data);
+  }
+
+  /**
+   * Read from private storage
+   */
+  async readPrivate(lens, key) {
+    return this.auth.readPrivate(lens, key);
+  }
+
+  /**
+   * Read all from private lens
+   */
+  async readAllPrivate(lens, timeout = 2000) {
+    return this.auth.readAllPrivate(lens, timeout);
+  }
+
+  /**
+   * Delete from private storage
+   */
+  async deletePrivate(lens, key) {
+    return this.auth.deletePrivate(lens, key);
+  }
+
+  // ============================================================================
+  // SCHEMA OPERATIONS
+  // ============================================================================
+
+  /**
+   * Set a schema for a lens
+   */
+  async setSchema(lens, schema) {
+    return this.schemaValidator.setSchema(this.gun, this.appName, lens, schema);
+  }
+
+  /**
+   * Get a schema for a lens
+   */
+  async getSchema(lens, options = {}) {
+    return this.schemaValidator.getSchema(this.gun, this.appName, lens, options);
+  }
+
+  /**
+   * Get all schemas
+   */
+  async getAllSchemas() {
+    return this.schemaValidator.getAllSchemas(this.gun, this.appName);
+  }
+
+  /**
+   * Delete a schema
+   */
+  async deleteSchema(lens) {
+    return this.schemaValidator.deleteSchema(this.gun, this.appName, lens);
+  }
+
+  /**
+   * Validate data against a schema
+   */
+  validate(schema, data) {
+    return this.schemaValidator.validate(schema, data);
+  }
+
+  /**
+   * Validate data against a lens schema
+   */
+  async validateData(lens, data) {
+    return this.schemaValidator.validateData(this.gun, this.appName, lens, data);
+  }
+
+  /**
+   * Clear schema cache
+   */
+  clearSchemaCache(lens = null) {
+    this.schemaValidator.clearCache(lens);
+  }
+
+  // ============================================================================
+  // SUBSCRIPTIONS
+  // ============================================================================
+
   async subscribe(path, callback, options = {}) {
-    // Determine if this is a prefix subscription (no key) or single item
+    const subscriptionId = ++this.subscriptionCounter;
     const pathParts = path.split('/');
     const isPrefix = pathParts.length <= 3;
 
+    const subscription = {
+      id: subscriptionId,
+      path,
+      active: true,
+      gunRef: null
+    };
+
     if (isPrefix) {
-      // Subscribe to all items under this prefix
       const ref = this.gun.get(path);
-      const handlers = [];
+      subscription.gunRef = ref;
+
+      ref.map().on(async (data, key) => {
+        if (!this.subscriptions.get(subscriptionId)?.active) return;
+        if (!data || key.startsWith('_') || data._deleted) return;
+
+        // Parse data
+        let parsed = wrapper.parse(data);
+        if (!parsed) return;
+
+        // Resolve references if requested
+        if (options.resolveReferences && this.isReference(parsed)) {
+          parsed = await this.resolveReference(parsed);
+        }
 
-      ref.map().on((data, key) => {
-        if (data && !key.startsWith('_') && !data._deleted) {
-          callback(data, key);
+        if (parsed) {
+          callback(parsed, key);
         }
       });
+    } else {
+      const ref = this.gun.get(path);
+      subscription.gunRef = ref;
 
-      // Store reference for cleanup
-      handlers.push(ref);
+      ref.on(async (data, key) => {
+        if (!this.subscriptions.get(subscriptionId)?.active) return;
+        if (!data) return;
 
-      return {
-        unsubscribe: () => {
-          handlers.forEach(h => {
-            try {
-              h.off();
-            } catch (e) {
-              // Ignore cleanup errors
-            }
-          });
-        },
-      };
-    } else {
-      // Subscribe to single item
-      const unsubFn = wrapper.subscribe(this.gun, path, callback);
-      return {
-        unsubscribe: typeof unsubFn === 'function' ? unsubFn : () => {},
-      };
+        let parsed = wrapper.parse(data);
+        if (!parsed || parsed._deleted) return;
+
+        if (options.resolveReferences && this.isReference(parsed)) {
+          parsed = await this.resolveReference(parsed);
+        }
+
+        if (parsed) {
+          callback(parsed, key);
+        }
+      });
     }
+
+    this.subscriptions.set(subscriptionId, subscription);
+
+    return {
+      id: subscriptionId,
+      unsubscribe: () => {
+        const sub = this.subscriptions.get(subscriptionId);
+        if (sub) {
+          sub.active = false;
+          if (sub.gunRef) {
+            try {
+              sub.gunRef.off();
+            } catch (e) {}
+          }
+          this.subscriptions.delete(subscriptionId);
+        }
+      }
+    };
   }
 
+  // ============================================================================
+  // EXPORT/IMPORT
+  // ============================================================================
+
   async exportData(pathPrefix = '') {
     const records = [];
-
-    // Get the app-level data
-    const appName = this.config.appName || 'holosphere';
-    const basePath = pathPrefix || appName;
+    const basePath = pathPrefix || this.appName;
 
     try {
       const items = await gunMap(this.gun.get(basePath), 2000);
 
       for (const [key, data] of Object.entries(items)) {
         if (!key.startsWith('_') && data && typeof data === 'object' && !data._deleted) {
-          // Recursively collect nested data
           await this._collectRecords(basePath, key, data, records);
         }
       }
@@ -164,14 +763,12 @@ export class GunDBBackend extends StorageBackend {
     const currentPath = `${basePath}/${key}`;
 
     if (data.id) {
-      // This is a leaf data node
       records.push({
         path: currentPath,
         data: this._cleanGunData(data),
         timestamp: data._meta?.timestamp || Date.now(),
       });
     } else {
-      // This might be a nested structure, explore further
       try {
         const nested = await gunMap(this.gun.get(currentPath), 500);
         for (const [nestedKey, nestedData] of Object.entries(nested)) {
@@ -179,14 +776,11 @@ export class GunDBBackend extends StorageBackend {
             await this._collectRecords(currentPath, nestedKey, nestedData, records);
           }
         }
-      } catch (e) {
-        // Ignore nested exploration errors
-      }
+      } catch (e) {}
     }
   }
 
   _cleanGunData(data) {
-    // Remove Gun's internal metadata
     const cleaned = { ...data };
     delete cleaned['_'];
     return cleaned;
@@ -208,14 +802,59 @@ export class GunDBBackend extends StorageBackend {
     return results;
   }
 
+  // ============================================================================
+  // LIFECYCLE
+  // ============================================================================
+
   close() {
-    // Gun doesn't have explicit close, but we can try to clean up
+    // 1. Unsubscribe all active subscriptions
+    for (const [id, subscription] of this.subscriptions) {
+      if (subscription.active) {
+        subscription.active = false;
+        if (subscription.gunRef) {
+          try {
+            subscription.gunRef.off();
+          } catch (e) {}
+        }
+      }
+    }
+    this.subscriptions.clear();
+
+    // 2. Clear schema cache
+    if (this.schemaValidator) {
+      this.schemaValidator.clearCache();
+    }
+
+    // 3. Clear write cache
+    this.writeCache.clear();
+
+    // 4. Logout auth
+    if (this.auth) {
+      this.auth.logout();
+    }
+
+    // 5. Clean up Gun connections
     if (this.gun) {
       try {
-        // Attempt to close any connections
+        // Clean up mesh connections
+        const mesh = this.gun.back('opt.mesh');
+        if (mesh) {
+          if (mesh.way) {
+            Object.values(mesh.way).forEach(conn => {
+              if (conn?.wire?.close) conn.wire.close();
+            });
+          }
+          if (mesh.opt?.peers) mesh.opt.peers = {};
+        }
+
+        // Close web server if present
+        const server = this.gun.back('opt.web');
+        if (server?.close) server.close();
+
+        // Turn off all listeners
         this.gun.off();
-      } catch (e) {
-        // Ignore cleanup errors
+      } catch (error) {
+        console.warn('Error during Gun cleanup:', error);
       }
     }
   }
@@ -226,6 +865,9 @@ export class GunDBBackend extends StorageBackend {
       publicKey: this.publicKey,
       peers: this.config.peers || [],
       connected: !!this.gun,
+      authenticated: this.isAuthenticated(),
+      subscriptionCount: this.subscriptions.size,
+      schemaValidationEnabled: this.schemaValidator?.isStrict() || false
     };
   }
 }