@soulcraft/brainy 3.0.1 → 3.1.1

package/README.md

@@ -11,11 +11,11 @@
 
 **🧠 Brainy 3.0 - Universal Knowledge Protocol™**
 
-**World's first Triple Intelligence™ database** unifying vector similarity, graph relationships, and document filtering in one magical API. Model ANY data from ANY domain using 31 standardized noun types × 40 verb types.
+**World's first Triple Intelligence™ database** unifying vector similarity, graph relationships, and document filtering in one magical API. **Framework-friendly design** works seamlessly with Next.js, React, Vue, Angular, and any modern JavaScript framework.
 
 **Why Brainy Leads**: We're the first to solve the impossible—combining three different database paradigms (vector, graph, document) into one unified query interface. This breakthrough enables us to be the Universal Knowledge Protocol where all tools, augmentations, and AI models speak the same language.
 
-**Build once, integrate everywhere.** O(log n) performance, <10ms search latency, production-ready.
+**Framework-first design.** Built for modern web development with zero configuration and automatic framework compatibility. O(log n) performance, <10ms search latency, production-ready.
 
 ## 🎉 What's New in 3.0
 
@@ -98,6 +98,73 @@ const filtered = await brain.find({
 })
 ```
 
+## 🌐 Framework Integration
+
+**Brainy 3.0 is framework-first!** Works seamlessly with any modern JavaScript framework:
+
+### ⚛️ **React & Next.js**
+```javascript
+import { Brainy } from '@soulcraft/brainy'
+
+function SearchComponent() {
+  const [brain] = useState(() => new Brainy())
+
+  useEffect(() => {
+    brain.init()
+  }, [])
+
+  const handleSearch = async (query) => {
+    const results = await brain.find(query)
+    setResults(results)
+  }
+}
+```
+
+### 🟢 **Vue.js & Nuxt.js**
+```javascript
+import { Brainy } from '@soulcraft/brainy'
+
+export default {
+  async mounted() {
+    this.brain = new Brainy()
+    await this.brain.init()
+  },
+  methods: {
+    async search(query) {
+      return await this.brain.find(query)
+    }
+  }
+}
+```
+
+### 🅰️ **Angular**
+```typescript
+import { Injectable } from '@angular/core'
+import { Brainy } from '@soulcraft/brainy'
+
+@Injectable({ providedIn: 'root' })
+export class BrainyService {
+  private brain = new Brainy()
+
+  async init() {
+    await this.brain.init()
+  }
+
+  async search(query: string) {
+    return await this.brain.find(query)
+  }
+}
+```
+
+### 🔥 **Other Frameworks**
+Brainy works with **any** framework that supports ES6 imports: Svelte, Solid.js, Qwik, Fresh, and more!
+
+**Framework Compatibility:**
+- ✅ All modern bundlers (Webpack, Vite, Rollup, Parcel)
+- ✅ SSR/SSG (Next.js, Nuxt, SvelteKit, Astro)
+- ✅ Edge runtimes (Vercel Edge, Cloudflare Workers)
+- ✅ Browser and Node.js environments
+
 ## 📋 System Requirements
 
 **Node.js Version:** 22 LTS or later (recommended)
@@ -436,9 +503,9 @@ const brain = new Brainy({
     }
 })
 
-// Browser Storage (OPFS)
+// Browser Storage (OPFS) - Works with frameworks
 const brain = new Brainy({
-    storage: {type: 'opfs'}
+    storage: {type: 'opfs'}  // Framework handles browser polyfills
 })
 
 // S3 Compatible (Production)
@@ -629,6 +696,12 @@ We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 ## 📖 Documentation
 
+### Framework Integration
+- [Framework Integration Guide](docs/guides/framework-integration.md) - **NEW!** Complete framework setup guide
+- [Next.js Integration](docs/guides/nextjs-integration.md) - **NEW!** React and Next.js examples
+- [Vue.js Integration](docs/guides/vue-integration.md) - **NEW!** Vue and Nuxt examples
+
+### Core Documentation
 - [Getting Started Guide](docs/guides/getting-started.md)
 - [API Reference](docs/api/README.md)
 - [Architecture Overview](docs/architecture/overview.md)

package/dist/brainy.d.ts

@@ -7,7 +7,7 @@
 import { ImprovedNeuralAPI } from './neural/improvedNeuralAPI.js';
 import { NaturalLanguageProcessor } from './neural/naturalLanguageProcessor.js';
 import { TripleIntelligenceSystem } from './triple/TripleIntelligenceSystem.js';
-import { Entity, Relation, Result, AddParams, UpdateParams, RelateParams, FindParams, SimilarParams, GetRelationsParams, AddManyParams, DeleteManyParams, BatchResult, BrainyConfig } from './types/brainy.types.js';
+import { Entity, Relation, Result, AddParams, UpdateParams, RelateParams, FindParams, SimilarParams, GetRelationsParams, AddManyParams, DeleteManyParams, RelateManyParams, BatchResult, BrainyConfig } from './types/brainy.types.js';
 import { NounType } from './types/graphTypes.js';
 /**
  * The main Brainy class - Clean, Beautiful, Powerful
@@ -98,6 +98,10 @@ export declare class Brainy<T = any> {
         continueOnError?: boolean;
         onProgress?: (completed: number, total: number) => void;
     }): Promise<BatchResult<string>>;
+    /**
+     * Create multiple relationships with batch processing
+     */
+    relateMany(params: RelateManyParams<T>): Promise<string[]>;
     /**
      * Clear all data from the database
      */

package/dist/brainy.js

@@ -16,6 +16,7 @@ import { NaturalLanguageProcessor } from './neural/naturalLanguageProcessor.js';
 import { TripleIntelligenceSystem } from './triple/TripleIntelligenceSystem.js';
 import { MetadataIndexManager } from './utils/metadataIndex.js';
 import { GraphAdjacencyIndex } from './graph/graphAdjacencyIndex.js';
+import { configureLogger, LogLevel } from './utils/logger.js';
 import { NounType } from './types/graphTypes.js';
 /**
  * The main Brainy class - Clean, Beautiful, Powerful
@@ -50,13 +51,22 @@ export class Brainy {
                 storage: { ...this.config.storage, ...configOverrides.storage },
                 model: { ...this.config.model, ...configOverrides.model },
                 index: { ...this.config.index, ...configOverrides.index },
-                augmentations: { ...this.config.augmentations, ...configOverrides.augmentations }
+                augmentations: { ...this.config.augmentations, ...configOverrides.augmentations },
+                verbose: configOverrides.verbose ?? this.config.verbose,
+                silent: configOverrides.silent ?? this.config.silent
             };
             // Set dimensions if provided
             if (dimensions) {
                 this.dimensions = dimensions;
             }
         }
+        // Configure logging based on config options
+        if (this.config.silent) {
+            configureLogger({ level: -1 }); // Suppress all logs
+        }
+        else if (this.config.verbose) {
+            configureLogger({ level: LogLevel.DEBUG }); // Enable verbose logging
+        }
         try {
             // Setup and initialize storage
             this.storage = await this.setupStorage();
@@ -663,6 +673,66 @@ export class Brainy {
         result.duration = Date.now() - startTime;
         return result;
     }
+    /**
+     * Create multiple relationships with batch processing
+     */
+    async relateMany(params) {
+        await this.ensureInitialized();
+        const result = {
+            successful: [],
+            failed: [],
+            total: params.items.length,
+            duration: 0
+        };
+        const startTime = Date.now();
+        const chunkSize = params.chunkSize || 100;
+        for (let i = 0; i < params.items.length; i += chunkSize) {
+            const chunk = params.items.slice(i, i + chunkSize);
+            if (params.parallel) {
+                // Process chunk in parallel
+                const promises = chunk.map(async (item) => {
+                    try {
+                        const relationId = await this.relate(item);
+                        result.successful.push(relationId);
+                    }
+                    catch (error) {
+                        result.failed.push({
+                            item,
+                            error: error.message || 'Unknown error'
+                        });
+                        if (!params.continueOnError) {
+                            throw error;
+                        }
+                    }
+                });
+                await Promise.all(promises);
+            }
+            else {
+                // Process chunk sequentially
+                for (const item of chunk) {
+                    try {
+                        const relationId = await this.relate(item);
+                        result.successful.push(relationId);
+                    }
+                    catch (error) {
+                        result.failed.push({
+                            item,
+                            error: error.message || 'Unknown error'
+                        });
+                        if (!params.continueOnError) {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            // Report progress
+            if (params.onProgress) {
+                params.onProgress(result.successful.length + result.failed.length, result.total);
+            }
+        }
+        result.duration = Date.now() - startTime;
+        return result.successful;
+    }
     /**
      * Clear all data from the database
      */
@@ -1130,7 +1200,9 @@ export class Brainy {
             warmup: config?.warmup ?? false,
             realtime: config?.realtime ?? false,
             multiTenancy: config?.multiTenancy ?? false,
-            telemetry: config?.telemetry ?? false
+            telemetry: config?.telemetry ?? false,
+            verbose: config?.verbose ?? false,
+            silent: config?.silent ?? false
         };
     }
     /**

package/dist/neural/embeddedPatterns.js

@@ -4040,5 +4040,7 @@ export const PATTERNS_METADATA = {
         total: 403493
     }
 };
-console.log(`🧠 Brainy Pattern Library loaded: ${EMBEDDED_PATTERNS.length} patterns, ${(PATTERNS_METADATA.sizeBytes.total / 1024).toFixed(1)}KB total`);
+// Only log if not suppressed - controlled by logging configuration
+import { prodLog } from '../utils/logger.js';
+prodLog.info(`🧠 Brainy Pattern Library loaded: ${EMBEDDED_PATTERNS.length} patterns, ${(PATTERNS_METADATA.sizeBytes.total / 1024).toFixed(1)}KB total`);
 //# sourceMappingURL=embeddedPatterns.js.map

package/dist/storage/adapters/fileSystemStorage.js

@@ -503,8 +503,23 @@ export class FileSystemStorage extends BaseStorage {
             }
             // Get page of files
             const pageFiles = nounFiles.slice(startIndex, startIndex + limit);
-            // Load nouns
+            // Load nouns - count actual successfully loaded items
             const items = [];
+            let successfullyLoaded = 0;
+            let totalValidFiles = 0;
+            // First pass: count total valid files (for accurate totalCount)
+            // This is necessary to fix the pagination bug
+            for (const file of nounFiles) {
+                try {
+                    // Just check if file exists and is readable
+                    await fs.promises.access(path.join(this.nounsDir, file), fs.constants.R_OK);
+                    totalValidFiles++;
+                }
+                catch {
+                    // File not readable, skip
+                }
+            }
+            // Second pass: load the current page
             for (const file of pageFiles) {
                 try {
                     const data = await fs.promises.readFile(path.join(this.nounsDir, file), 'utf-8');
@@ -523,18 +538,21 @@ export class FileSystemStorage extends BaseStorage {
                             continue;
                     }
                     items.push(noun);
+                    successfullyLoaded++;
                 }
                 catch (error) {
                     console.warn(`Failed to read noun file ${file}:`, error);
                 }
             }
-            const hasMore = startIndex + limit < nounFiles.length;
+            // CRITICAL FIX: hasMore should be based on actual valid files, not just file count
+            // Also check if we actually loaded any items from this page
+            const hasMore = (startIndex + limit < totalValidFiles) && (successfullyLoaded > 0 || startIndex === 0);
             const nextCursor = hasMore && pageFiles.length > 0
                 ? pageFiles[pageFiles.length - 1].replace('.json', '')
                 : undefined;
             return {
                 items,
-                totalCount: nounFiles.length,
+                totalCount: totalValidFiles, // Use actual valid file count, not all files
                 hasMore,
                 nextCursor
             };

package/dist/storage/baseStorage.js

@@ -345,10 +345,14 @@ export class BaseStorage extends BaseStorageAdapter {
                 });
                 // Apply offset if needed (some adapters might not support offset)
                 const items = result.items.slice(offset);
+                // CRITICAL SAFETY CHECK: Prevent infinite loops
+                // If we have no items but hasMore is true, force hasMore to false
+                // This prevents pagination bugs from causing infinite loops
+                const safeHasMore = items.length > 0 ? result.hasMore : false;
                 return {
                     items,
                     totalCount: result.totalCount || totalCount,
-                    hasMore: result.hasMore,
+                    hasMore: safeHasMore,
                     nextCursor: result.nextCursor
                 };
             }
@@ -490,10 +494,14 @@ export class BaseStorage extends BaseStorageAdapter {
                 });
                 // Apply offset if needed (some adapters might not support offset)
                 const items = result.items.slice(offset);
+                // CRITICAL SAFETY CHECK: Prevent infinite loops
+                // If we have no items but hasMore is true, force hasMore to false
+                // This prevents pagination bugs from causing infinite loops
+                const safeHasMore = items.length > 0 ? result.hasMore : false;
                 return {
                     items,
                     totalCount: result.totalCount || totalCount,
-                    hasMore: result.hasMore,
+                    hasMore: safeHasMore,
                     nextCursor: result.nextCursor
                 };
             }

package/dist/types/brainy.types.d.ts

@@ -273,6 +273,8 @@ export interface BrainyConfig {
     realtime?: boolean;
     multiTenancy?: boolean;
     telemetry?: boolean;
+    verbose?: boolean;
+    silent?: boolean;
 }
 /**
  * Neural similarity parameters

package/dist/universal/crypto.d.ts

@@ -1,17 +1,21 @@
 /**
  * Universal Crypto implementation
- * Works in all environments: Browser, Node.js, Serverless
+ * Framework-friendly: Trusts that frameworks provide crypto polyfills
+ * Works in all environments: Browser (via framework), Node.js, Serverless
  */
 /**
  * Generate random bytes
+ * Framework-friendly: Assumes crypto API is available via framework polyfills
  */
 export declare function randomBytes(size: number): Uint8Array;
 /**
  * Generate random UUID
+ * Framework-friendly: Assumes crypto.randomUUID is available via framework polyfills
  */
 export declare function randomUUID(): string;
 /**
  * Create hash (simplified interface)
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function createHash(algorithm: string): {
     update: (data: string | Uint8Array) => any;
@@ -19,6 +23,7 @@ export declare function createHash(algorithm: string): {
 };
 /**
  * Create HMAC
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function createHmac(algorithm: string, key: string | Uint8Array): {
     update: (data: string | Uint8Array) => any;
@@ -26,14 +31,17 @@ export declare function createHmac(algorithm: string, key: string | Uint8Array):
 };
 /**
  * PBKDF2 synchronous
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function pbkdf2Sync(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string): Uint8Array;
 /**
  * Scrypt synchronous
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, keylen: number, options?: any): Uint8Array;
 /**
  * Create cipher
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function createCipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
     update: (data: string, inputEncoding?: string, outputEncoding?: string) => string;
@@ -41,6 +49,7 @@ export declare function createCipheriv(algorithm: string, key: Uint8Array, iv: U
 };
 /**
  * Create decipher
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function createDecipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
     update: (data: string, inputEncoding?: string, outputEncoding?: string) => string;
@@ -48,6 +57,7 @@ export declare function createDecipheriv(algorithm: string, key: Uint8Array, iv:
 };
 /**
  * Timing safe equal
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
 declare const _default: {

package/dist/universal/crypto.js

@@ -1,8 +1,9 @@
 /**
  * Universal Crypto implementation
- * Works in all environments: Browser, Node.js, Serverless
+ * Framework-friendly: Trusts that frameworks provide crypto polyfills
+ * Works in all environments: Browser (via framework), Node.js, Serverless
  */
-import { isBrowser, isNode } from '../utils/environment.js';
+import { isNode } from '../utils/environment.js';
 let nodeCrypto = null;
 // Dynamic import for Node.js crypto (only in Node.js environment)
 if (isNode()) {
@@ -15,29 +16,26 @@ if (isNode()) {
 }
 /**
  * Generate random bytes
+ * Framework-friendly: Assumes crypto API is available via framework polyfills
  */
 export function randomBytes(size) {
-    if (isBrowser() || typeof crypto !== 'undefined') {
-        // Use Web Crypto API (available in browsers and modern Node.js)
+    if (typeof crypto !== 'undefined') {
+        // Use Web Crypto API (available in browsers via framework polyfills and modern Node.js)
         const array = new Uint8Array(size);
         crypto.getRandomValues(array);
         return array;
     }
     else if (nodeCrypto) {
-        // Use Node.js crypto as fallback
+        // Use Node.js crypto
         return new Uint8Array(nodeCrypto.randomBytes(size));
     }
     else {
-        // Fallback for environments without crypto
-        const array = new Uint8Array(size);
-        for (let i = 0; i < size; i++) {
-            array[i] = Math.floor(Math.random() * 256);
-        }
-        return array;
+        throw new Error('Crypto API not available. Framework bundlers should provide crypto polyfills.');
     }
 }
 /**
  * Generate random UUID
+ * Framework-friendly: Assumes crypto.randomUUID is available via framework polyfills
  */
 export function randomUUID() {
     if (typeof crypto !== 'undefined' && crypto.randomUUID) {
@@ -47,158 +45,91 @@ export function randomUUID() {
         return nodeCrypto.randomUUID();
     }
     else {
-        // Fallback UUID generation
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
+        throw new Error('crypto.randomUUID not available. Framework bundlers should provide crypto polyfills.');
     }
 }
 /**
  * Create hash (simplified interface)
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function createHash(algorithm) {
     if (nodeCrypto && nodeCrypto.createHash) {
         return nodeCrypto.createHash(algorithm);
     }
     else {
-        // Simple fallback hash for browsers (not cryptographically secure)
-        let hash = 0;
-        const hashObj = {
-            update: (data) => {
-                const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
-                for (let i = 0; i < text.length; i++) {
-                    const char = text.charCodeAt(i);
-                    hash = ((hash << 5) - hash) + char;
-                    hash = hash & hash; // Convert to 32-bit integer
-                }
-                return hashObj;
-            },
-            digest: (encoding) => {
-                return Math.abs(hash).toString(16);
-            }
-        };
-        return hashObj;
+        throw new Error(`createHash not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * Create HMAC
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function createHmac(algorithm, key) {
     if (nodeCrypto && nodeCrypto.createHmac) {
         return nodeCrypto.createHmac(algorithm, key);
     }
     else {
-        // Fallback HMAC implementation (simplified)
-        return createHash(algorithm);
+        throw new Error(`createHmac not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * PBKDF2 synchronous
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
     if (nodeCrypto && nodeCrypto.pbkdf2Sync) {
         return new Uint8Array(nodeCrypto.pbkdf2Sync(password, salt, iterations, keylen, digest));
     }
     else {
-        // Simplified fallback (not cryptographically secure)
-        const result = new Uint8Array(keylen);
-        const passwordStr = typeof password === 'string' ? password : new TextDecoder().decode(password);
-        const saltStr = typeof salt === 'string' ? salt : new TextDecoder().decode(salt);
-        let hash = 0;
-        const combined = passwordStr + saltStr;
-        for (let i = 0; i < combined.length; i++) {
-            hash = ((hash << 5) - hash) + combined.charCodeAt(i);
-            hash = hash & hash;
-        }
-        for (let i = 0; i < keylen; i++) {
-            result[i] = (Math.abs(hash + i) % 256);
-        }
-        return result;
+        throw new Error(`pbkdf2Sync not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * Scrypt synchronous
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function scryptSync(password, salt, keylen, options) {
     if (nodeCrypto && nodeCrypto.scryptSync) {
         return new Uint8Array(nodeCrypto.scryptSync(password, salt, keylen, options));
     }
     else {
-        // Fallback to pbkdf2Sync
-        return pbkdf2Sync(password, salt, 10000, keylen, 'sha256');
+        throw new Error(`scryptSync not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * Create cipher
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function createCipheriv(algorithm, key, iv) {
     if (nodeCrypto && nodeCrypto.createCipheriv) {
         return nodeCrypto.createCipheriv(algorithm, key, iv);
     }
     else {
-        // Fallback encryption (XOR-based, not secure)
-        let encrypted = '';
-        return {
-            update: (data, inputEncoding, outputEncoding) => {
-                for (let i = 0; i < data.length; i++) {
-                    const char = data.charCodeAt(i);
-                    const keyByte = key[i % key.length];
-                    const ivByte = iv[i % iv.length];
-                    encrypted += String.fromCharCode(char ^ keyByte ^ ivByte);
-                }
-                return outputEncoding === 'hex' ? Buffer.from(encrypted, 'binary').toString('hex') : encrypted;
-            },
-            final: (outputEncoding) => {
-                return outputEncoding === 'hex' ? '' : '';
-            }
-        };
+        throw new Error(`createCipheriv not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * Create decipher
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function createDecipheriv(algorithm, key, iv) {
     if (nodeCrypto && nodeCrypto.createDecipheriv) {
         return nodeCrypto.createDecipheriv(algorithm, key, iv);
     }
     else {
-        // Fallback decryption (XOR-based, matches createCipheriv)
-        let decrypted = '';
-        return {
-            update: (data, inputEncoding, outputEncoding) => {
-                const input = inputEncoding === 'hex' ? Buffer.from(data, 'hex').toString('binary') : data;
-                for (let i = 0; i < input.length; i++) {
-                    const char = input.charCodeAt(i);
-                    const keyByte = key[i % key.length];
-                    const ivByte = iv[i % iv.length];
-                    decrypted += String.fromCharCode(char ^ keyByte ^ ivByte);
-                }
-                return decrypted;
-            },
-            final: (outputEncoding) => {
-                return '';
-            }
-        };
+        throw new Error(`createDecipheriv not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 /**
  * Timing safe equal
+ * Framework-friendly: Relies on Node.js crypto or framework-provided implementations
  */
 export function timingSafeEqual(a, b) {
     if (nodeCrypto && nodeCrypto.timingSafeEqual) {
         return nodeCrypto.timingSafeEqual(a, b);
     }
     else {
-        // Fallback implementation
-        if (a.length !== b.length)
-            return false;
-        let result = 0;
-        for (let i = 0; i < a.length; i++) {
-            result |= a[i] ^ b[i];
-        }
-        return result === 0;
+        throw new Error(`timingSafeEqual not available. For browser environments, frameworks should provide crypto polyfills or use Web Crypto API directly.`);
     }
 }
 export default {

package/dist/universal/events.d.ts

@@ -1,7 +1,7 @@
 /**
  * Universal Events implementation
- * Browser: Uses EventTarget API
- * Node.js: Uses built-in events module
+ * Framework-friendly: Trusts that frameworks provide events polyfills
+ * Works in all environments: Browser (via framework), Node.js, Serverless
  */
 /**
  * Universal EventEmitter interface
@@ -16,6 +16,7 @@ export interface UniversalEventEmitter {
 }
 /**
  * Universal EventEmitter class
+ * Framework-friendly: Assumes events API is available via framework polyfills
  */
 export declare class EventEmitter implements UniversalEventEmitter {
     private emitter;