holosphere 2.0.0-alpha2 → 2.0.0-alpha4

package/src/storage/nostr-async.js

@@ -96,13 +96,17 @@ export async function nostrGet(client, path, kind = 30000, options = {}) {
 
   try {
     const data = JSON.parse(event.content);
+    // Skip deleted items
+    if (data._deleted) {
+      return null;
+    }
     // Optionally include author information
     if (options.includeAuthor) {
       data._author = event.pubkey;
     }
     return data;
   } catch (error) {
-    console.error('Failed to parse event content:', error);
+    // Silent - return null for unparseable events
     return null;
   }
 }
@@ -143,8 +147,11 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
           try {
             const data = JSON.parse(event.content);
 
-            // Skip deleted items
-            if (data._deleted) continue;
+            // Handle deleted items - remove from map if this is newer
+            if (data._deleted) {
+              byPath.delete(path);
+              continue;
+            }
 
             // Optionally include author information
             if (options.includeAuthor) {
@@ -192,8 +199,11 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
       try {
         const data = JSON.parse(event.content);
 
-        // Skip deleted items
-        if (data._deleted) continue;
+        // Handle deleted items - remove from map if this is newer
+        if (data._deleted) {
+          byPath.delete(dTag);
+          continue;
+        }
 
         // Optionally include author information
         if (options.includeAuthor) {
@@ -201,7 +211,7 @@ export async function nostrGetAll(client, pathPrefix, kind = 30000, options = {}
         }
         byPath.set(dTag, { data, created_at: event.created_at });
       } catch (error) {
-        console.error('Failed to parse event content:', error);
+        // Silent - skip unparseable events
       }
     }
   }
@@ -252,13 +262,22 @@ export async function nostrGetAllHybrid(client, pathPrefix, kind = 30000, option
     if (!existing || event.created_at > existing.created_at) {
       try {
         const data = JSON.parse(event.content);
+        // Skip null or non-object content
+        if (data === null || typeof data !== 'object') {
+          continue;
+        }
+        // Handle deleted items - remove from map if this is newer
+        if (data._deleted) {
+          byPath.delete(dTag);
+          continue;
+        }
         // Optionally include author information
         if (options.includeAuthor) {
           data._author = event.pubkey;
         }
         byPath.set(dTag, { data, created_at: event.created_at });
       } catch (error) {
-        console.error('Failed to parse event content:', error);
+        // Silent - skip unparseable events
       }
     }
   }
@@ -319,14 +338,10 @@ export async function nostrDelete(client, path, kind = 30000) {
 
   // Publish deletion event (best effort, don't block on failure)
   try {
-    const publishResult = await client.publish(deletionEvent);
-    console.log(`✅ NIP-09 deletion event published for ${path}:`, {
-      coordinate,
-      relays: publishResult?.relays?.length || 0,
-      successful: publishResult?.successful || []
-    });
+    await client.publish(deletionEvent);
+    // Silent success - deletion queued
   } catch (error) {
-    console.error(`❌ Failed to publish NIP-09 deletion event for ${path}:`, error.message);
+    // Silent - deletion will be retried
   }
 
   return result;
@@ -438,15 +453,10 @@ export async function nostrDeleteAll(client, pathPrefix, kind = 30000) {
       content: '', // Optional deletion reason/note
     };
 
-    const publishResult = await client.publish(deletionEvent);
-    console.log(`✅ NIP-09 bulk deletion event published for ${pathPrefix}:`, {
-      itemsDeleted: matching.length,
-      coordinates: coordinates.length,
-      relays: publishResult?.relays?.length || 0,
-      successful: publishResult?.successful || []
-    });
+    await client.publish(deletionEvent);
+    // Silent success - bulk deletion queued
   } catch (error) {
-    console.error(`❌ Failed to publish NIP-09 bulk deletion event for ${pathPrefix}:`, error.message);
+    // Silent - bulk deletion will be retried
   }
 
   return {
@@ -492,6 +502,12 @@ export function nostrSubscribe(client, path, callback, options = {}) {
 
       try {
         const data = JSON.parse(event.content);
+
+        // Skip deleted items - don't send tombstones to subscribers
+        if (data._deleted) {
+          return;
+        }
+
         callback(data, event);
       } catch (error) {
         console.error('Failed to parse event in subscription:', error);
@@ -589,9 +605,15 @@ export async function nostrSubscribeMany(client, pathPrefix, callback, options =
 
     // Client-side prefix filter
     if (dTag && dTag.startsWith(pathPrefix)) {
-      acceptedCount++;
       try {
         const data = JSON.parse(event.content);
+
+        // Skip deleted items - don't send tombstones to subscribers
+        if (data._deleted) {
+          return;
+        }
+
+        acceptedCount++;
         // Notify all registered callbacks
         for (const cb of callbacks) {
           cb(data, dTag, event);

package/src/storage/nostr-client.js

@@ -256,8 +256,8 @@ export class NostrClient {
       };
     } else {
       // Fire and forget - publish in background, return immediately
-      this._attemptDelivery(signedEvent, this.relays).catch(err => {
-        console.warn('[nostr] Immediate delivery failed, queued for retry:', err.message);
+      this._attemptDelivery(signedEvent, this.relays).catch(() => {
+        // Silent - event is cached locally and queued for retry
       });
 
       // Return immediately (data is in local cache and queued for delivery)
@@ -305,13 +305,19 @@ export class NostrClient {
       await this.outboxQueue.markSent(event.id, successful);
     }
 
-    // Log failures for debugging
-    if (failed.length > 0) {
+    // Log failures only at debug level (common during network issues)
+    if (failed.length > 0 && successful.length === 0) {
+      // Only warn if ALL relays failed (likely a real issue)
       const reasons = results
         .filter(r => r.status === 'rejected')
         .map(f => f.reason?.message || f.reason || 'unknown')
         .join(', ');
-      console.warn(`[nostr] ${failed.length}/${relays.length} relays failed for ${event.id.slice(0, 8)}: ${reasons}`);
+      // Use debug level for timeout issues (very common)
+      if (reasons.includes('timed out')) {
+        // Silent - event is queued for retry anyway
+      } else {
+        console.warn(`[nostr] All relays failed for ${event.id.slice(0, 8)}: ${reasons}`);
+      }
     }
 
     return { successful, failed, results: formattedResults };

package/src/storage/persistent-storage.js

@@ -10,6 +10,7 @@ class PersistentStorage {
   /**
    * Initialize storage
    * @param {string} namespace - Storage namespace (appName)
+   * @returns {Promise<void>}
    */
   async init(namespace) {
     throw new Error('init() must be implemented by subclass');
@@ -19,6 +20,7 @@ class PersistentStorage {
    * Store event
    * @param {string} key - Event ID or d-tag
    * @param {Object} event - Nostr event
+   * @returns {Promise<void>}
    */
   async put(key, event) {
     throw new Error('put() must be implemented by subclass');
@@ -36,7 +38,7 @@ class PersistentStorage {
   /**
    * Get all events matching prefix
    * @param {string} prefix - Key prefix
-   * @returns {Promise<Object[]>} Array of events
+   * @returns {Promise<any[]>} Array of events
    */
   async getAll(prefix) {
     throw new Error('getAll() must be implemented by subclass');
@@ -45,6 +47,7 @@ class PersistentStorage {
   /**
    * Delete event
    * @param {string} key - Event ID or d-tag
+   * @returns {Promise<void>}
    */
   async delete(key) {
     throw new Error('delete() must be implemented by subclass');
@@ -52,6 +55,7 @@ class PersistentStorage {
 
   /**
    * Clear all data in namespace
+   * @returns {Promise<void>}
    */
   async clear() {
     throw new Error('clear() must be implemented by subclass');
@@ -59,6 +63,7 @@ class PersistentStorage {
 
   /**
    * Close storage
+   * @returns {Promise<void>}
    */
   async close() {
     throw new Error('close() must be implemented by subclass');

package/src/storage/unified-storage.js

@@ -0,0 +1,119 @@
+/**
+ * Unified Storage Adapter
+ * Routes storage operations to the correct backend (nostr or gundb)
+ */
+
+import * as nostrWrapper from './nostr-wrapper.js';
+import * as gunWrapper from './gun-wrapper.js';
+
+/**
+ * Build path from components
+ * @param {string} appName - Application namespace
+ * @param {string} holonId - Holon identifier
+ * @param {string} lensName - Lens name
+ * @param {string} [key] - Optional data key
+ * @returns {string} Constructed path
+ */
+export function buildPath(appName, holonId, lensName, key = null) {
+  // Both backends use the same path format
+  return nostrWrapper.buildPath(appName, holonId, lensName, key);
+}
+
+/**
+ * Write data to storage
+ * @param {Object} client - Client instance (nostr client or gun-compatible client)
+ * @param {string} path - Storage path
+ * @param {Object} data - Data to write
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function write(client, path, data) {
+  // Check if this is a GunDB client
+  if (client.gun) {
+    return gunWrapper.write(client.gun, path, data);
+  }
+  // Default to Nostr
+  return nostrWrapper.write(client, path, data);
+}
+
+/**
+ * Read data from storage
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @param {Object} [options] - Read options
+ * @returns {Promise<Object|null>} Data or null
+ */
+export async function read(client, path, options = {}) {
+  if (client.gun) {
+    return gunWrapper.read(client.gun, path);
+  }
+  return nostrWrapper.read(client, path, options);
+}
+
+/**
+ * Read all data under a path prefix
+ * @param {Object} client - Client instance
+ * @param {string} path - Path prefix
+ * @param {Object} [options] - Query options
+ * @returns {Promise<Object[]>} Array of data objects
+ */
+export async function readAll(client, path, options = {}) {
+  if (client.gun) {
+    return gunWrapper.readAll(client.gun, path);
+  }
+  return nostrWrapper.readAll(client, path, options);
+}
+
+/**
+ * Update data (merge fields)
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function update(client, path, updates) {
+  if (client.gun) {
+    return gunWrapper.update(client.gun, path, updates);
+  }
+  return nostrWrapper.update(client, path, updates);
+}
+
+/**
+ * Delete data at path
+ * @param {Object} client - Client instance
+ * @param {string} path - Storage path
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function deleteData(client, path) {
+  if (client.gun) {
+    return gunWrapper.deleteData(client.gun, path);
+  }
+  return nostrWrapper.deleteData(client, path);
+}
+
+/**
+ * Delete all data under path prefix
+ * @param {Object} client - Client instance
+ * @param {string} path - Path prefix
+ * @returns {Promise<Object>} Deletion results
+ */
+export async function deleteAll(client, path) {
+  if (client.gun) {
+    return gunWrapper.deleteAll(client.gun, path);
+  }
+  return nostrWrapper.deleteAll(client, path);
+}
+
+/**
+ * Subscribe to data changes
+ * @param {Object} client - Client instance
+ * @param {string} path - Path or path prefix
+ * @param {Function} callback - Called on changes
+ * @param {Object} [options] - Subscription options
+ * @returns {Object} Subscription with unsubscribe method
+ */
+export function subscribe(client, path, callback, options = {}) {
+  if (client.gun) {
+    return gunWrapper.subscribe(client.gun, path, callback, options);
+  }
+  return nostrWrapper.subscribe(client, path, callback, options);
+}

package/src/subscriptions/manager.js

@@ -2,7 +2,7 @@
  * Real-time Subscription Management
  */
 
-import { subscribe } from '../storage/nostr-wrapper.js';
+import { subscribe } from '../storage/unified-storage.js';
 import { resolveHologram } from '../federation/hologram.js';
 
 /**

package/types/index.d.ts

@@ -0,0 +1,133 @@
+// Type declarations for holosphere
+// This file tells TypeScript to skip type checking the bundled JS files
+
+declare module 'holosphere' {
+  export class HoloSphere {
+    constructor(config?: any);
+    init(): Promise<void>;
+
+    // Core CRUD operations
+    get(holonId: string, lens: string, key?: string): Promise<any>;
+    getAll(holonId: string, lens: string): Promise<Record<string, any>>;
+    put(holonId: string, lens: string, value: any): Promise<void>;
+    put(holonId: string, lens: string, key: string, value: any): Promise<void>;
+    delete(holonId: string, lens: string, key?: string): Promise<void>;
+    read(holonId: string, lens: string, key?: string): Promise<any>;
+
+    // Subscription
+    subscribe(holonId: string, lens: string, callback: (data: any, key: string) => void): Promise<{ unsubscribe: () => void }>;
+
+    // Profile operations
+    getHolonProfile(holonId: string): Promise<any>;
+    setHolonProfile(holonId: string, profile: any): Promise<void>;
+
+    // Federation operations
+    federate(sourceHolonId: string, targetHolonId: string, sourceKey?: string | null, targetKey?: string | null, bidirectional?: boolean, permissions?: any): Promise<void>;
+    federateHolon(holonId: string, targetHolonId: string, options?: any): Promise<void>;
+    getFederation(holonId: string): Promise<any>;
+    propagate(holonId: string, lens: string, key: string, value: any): Promise<void>;
+    propagateData(holonId: string, lens: string, data: any): Promise<void>;
+
+    // Global operations
+    getGlobal(lens: string, key?: string): Promise<any>;
+    getAllGlobal(lens: string): Promise<Record<string, any>>;
+    writeGlobal(lens: string, key: string, value: any): Promise<void>;
+
+    // Internal properties (exposed for advanced use)
+    gun?: any;
+    client?: any;
+  }
+
+  export class PersistentStorage {
+    init(namespace: string): Promise<void>;
+    put(key: string, event: any): Promise<void>;
+    get(key: string): Promise<any | null>;
+    getAll(prefix: string): Promise<any[]>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+  }
+
+  export class IndexedDBStorage extends PersistentStorage {}
+  export class MemoryStorage extends PersistentStorage {}
+  export class FileSystemStorage extends PersistentStorage {}
+
+  export class ChainManager {
+    constructor(config?: any);
+  }
+
+  export class ContractDeployer {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class ContractOperations {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class ContractQueries {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class EventListener {
+    constructor(chainManager: ChainManager);
+  }
+
+  export class HolonContracts {
+    constructor(config?: any);
+  }
+
+  export const ContractABIs: any;
+  export const NETWORKS: any;
+
+  export class AuthorizationError extends Error {}
+  export class ValidationError extends Error {}
+
+  export const crypto: any;
+  export const federation: any;
+  export const handshake: {
+    initiateFederationHandshake(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    acceptFederationRequest(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    rejectFederationRequest(holosphere: HoloSphere, privateKey: string, params: any): Promise<any>;
+    subscribeToFederationDMs(client: any, privateKey: string, publicKey: string, handlers: any): () => void;
+  };
+  export const hierarchical: any;
+  export const nostrUtils: any;
+  export const schema: any;
+  export const social: any;
+  export const spatial: any;
+  export const storage: any;
+  export const subscriptions: any;
+  export const networks: any;
+
+  export function createHologram(config?: any): any;
+  export function createAIServices(config?: any): any;
+  export function getNetwork(name: string): any;
+  export function getNetworksByType(type: string): any[];
+  export function listNetworks(): string[];
+  export function isNetworkSupported(name: string): boolean;
+  export function getAddressUrl(network: string, address: string): string;
+  export function getTxUrl(network: string, txHash: string): string;
+  export function matchScope(scope: string, pattern: string): boolean;
+
+  // AI-related exports
+  export class Classifier {}
+  export class Council {}
+  export class Embeddings {}
+  export class FederationAdvisor {}
+  export class H3AI {}
+  export class JSONOps {}
+  export class LLMService {}
+  export class NLQuery {}
+  export class RelationshipDiscovery {}
+  export class SchemaExtractor {}
+  export class SmartAggregation {}
+  export class SpatialAnalysis {}
+  export class TaskBreakdown {}
+  export class TTS {}
+
+  export const MODELS: any;
+  export const VOICES: any;
+  export const SANKEY_EVENTS: any;
+
+  export default HoloSphere;
+}