@soulcraft/brainy 3.0.0 → 3.1.0

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;

package/dist/universal/events.js

@@ -1,9 +1,9 @@
 /**
  * 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
  */
-import { isBrowser, isNode } from '../utils/environment.js';
+import { isNode } from '../utils/environment.js';
 let nodeEvents = null;
 // Dynamic import for Node.js events (only in Node.js environment)
 if (isNode()) {
@@ -14,73 +14,6 @@ if (isNode()) {
         // Ignore import errors in non-Node environments
     }
 }
-/**
- * Browser implementation using EventTarget
- */
-class BrowserEventEmitter extends EventTarget {
-    constructor() {
-        super(...arguments);
-        this.listeners = new Map();
-    }
-    on(event, listener) {
-        if (!this.listeners.has(event)) {
-            this.listeners.set(event, new Set());
-        }
-        this.listeners.get(event).add(listener);
-        const handler = (e) => {
-            const customEvent = e;
-            listener(...(customEvent.detail || []));
-        };
-        listener.__handler = handler;
-        this.addEventListener(event, handler);
-        return this;
-    }
-    off(event, listener) {
-        const eventListeners = this.listeners.get(event);
-        if (eventListeners) {
-            eventListeners.delete(listener);
-            const handler = listener.__handler;
-            if (handler) {
-                this.removeEventListener(event, handler);
-                delete listener.__handler;
-            }
-        }
-        return this;
-    }
-    emit(event, ...args) {
-        const customEvent = new CustomEvent(event, { detail: args });
-        this.dispatchEvent(customEvent);
-        const eventListeners = this.listeners.get(event);
-        return eventListeners ? eventListeners.size > 0 : false;
-    }
-    once(event, listener) {
-        const onceListener = (...args) => {
-            this.off(event, onceListener);
-            listener(...args);
-        };
-        return this.on(event, onceListener);
-    }
-    removeAllListeners(event) {
-        if (event) {
-            const eventListeners = this.listeners.get(event);
-            if (eventListeners) {
-                for (const listener of eventListeners) {
-                    this.off(event, listener);
-                }
-            }
-        }
-        else {
-            for (const [eventName] of this.listeners) {
-                this.removeAllListeners(eventName);
-            }
-        }
-        return this;
-    }
-    listenerCount(event) {
-        const eventListeners = this.listeners.get(event);
-        return eventListeners ? eventListeners.size : 0;
-    }
-}
 /**
  * Node.js implementation using events.EventEmitter
  */
@@ -113,17 +46,15 @@ class NodeEventEmitter {
 }
 /**
  * Universal EventEmitter class
+ * Framework-friendly: Assumes events API is available via framework polyfills
  */
 export class EventEmitter {
     constructor() {
-        if (isBrowser()) {
-            this.emitter = new BrowserEventEmitter();
-        }
-        else if (isNode() && nodeEvents) {
+        if (isNode() && nodeEvents) {
             this.emitter = new NodeEventEmitter();
         }
         else {
-            this.emitter = new BrowserEventEmitter();
+            throw new Error('Events operations not available. Framework bundlers should provide events polyfills.');
         }
     }
     on(event, listener) {

package/dist/universal/fs.d.ts

@@ -1,8 +1,7 @@
 /**
  * Universal File System implementation
- * Browser: Uses OPFS (Origin Private File System)
- * Node.js: Uses built-in fs/promises
- * Serverless: Uses memory-based fallback
+ * Framework-friendly: Trusts that frameworks provide fs polyfills
+ * Works in all environments: Browser (via framework), Node.js, Serverless
  */
 /**
  * Universal file operations interface

package/dist/universal/fs.js

@@ -1,10 +1,9 @@
 /**
  * Universal File System implementation
- * Browser: Uses OPFS (Origin Private File System)
- * Node.js: Uses built-in fs/promises
- * Serverless: Uses memory-based fallback
+ * Framework-friendly: Trusts that frameworks provide fs 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 nodeFs = null;
 // Dynamic import for Node.js fs (only in Node.js environment)
 if (isNode()) {
@@ -15,125 +14,6 @@ if (isNode()) {
         // Ignore import errors in non-Node environments
     }
 }
-/**
- * Browser implementation using OPFS
- */
-class BrowserFS {
-    async getRoot() {
-        if ('storage' in navigator && 'getDirectory' in navigator.storage) {
-            return await navigator.storage.getDirectory();
-        }
-        throw new Error('OPFS not supported in this browser');
-    }
-    async getFileHandle(path, create = false) {
-        const root = await this.getRoot();
-        const parts = path.split('/').filter(p => p);
-        let dir = root;
-        for (let i = 0; i < parts.length - 1; i++) {
-            dir = await dir.getDirectoryHandle(parts[i], { create });
-        }
-        const fileName = parts[parts.length - 1];
-        return await dir.getFileHandle(fileName, { create });
-    }
-    async getDirHandle(path, create = false) {
-        const root = await this.getRoot();
-        const parts = path.split('/').filter(p => p);
-        let dir = root;
-        for (const part of parts) {
-            dir = await dir.getDirectoryHandle(part, { create });
-        }
-        return dir;
-    }
-    async readFile(path, encoding) {
-        try {
-            const fileHandle = await this.getFileHandle(path);
-            const file = await fileHandle.getFile();
-            return await file.text();
-        }
-        catch (error) {
-            throw new Error(`File not found: ${path}`);
-        }
-    }
-    async writeFile(path, data, encoding) {
-        const fileHandle = await this.getFileHandle(path, true);
-        const writable = await fileHandle.createWritable();
-        await writable.write(data);
-        await writable.close();
-    }
-    async mkdir(path, options = { recursive: true }) {
-        await this.getDirHandle(path, true);
-    }
-    async exists(path) {
-        try {
-            await this.getFileHandle(path);
-            return true;
-        }
-        catch {
-            try {
-                await this.getDirHandle(path);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-    }
-    async readdir(path, options) {
-        const dir = await this.getDirHandle(path);
-        if (options?.withFileTypes) {
-            const entries = [];
-            for await (const [name, handle] of dir.entries()) {
-                entries.push({
-                    name,
-                    isDirectory: () => handle.kind === 'directory',
-                    isFile: () => handle.kind === 'file'
-                });
-            }
-            return entries;
-        }
-        else {
-            const entries = [];
-            for await (const [name] of dir.entries()) {
-                entries.push(name);
-            }
-            return entries;
-        }
-    }
-    async unlink(path) {
-        const parts = path.split('/').filter(p => p);
-        const fileName = parts.pop();
-        const dirPath = parts.join('/');
-        if (dirPath) {
-            const dir = await this.getDirHandle(dirPath);
-            await dir.removeEntry(fileName);
-        }
-        else {
-            const root = await this.getRoot();
-            await root.removeEntry(fileName);
-        }
-    }
-    async stat(path) {
-        try {
-            await this.getFileHandle(path);
-            return { isFile: () => true, isDirectory: () => false };
-        }
-        catch {
-            try {
-                await this.getDirHandle(path);
-                return { isFile: () => false, isDirectory: () => true };
-            }
-            catch {
-                throw new Error(`Path not found: ${path}`);
-            }
-        }
-    }
-    async access(path, mode) {
-        const exists = await this.exists(path);
-        if (!exists) {
-            throw new Error(`ENOENT: no such file or directory, access '${path}'`);
-        }
-    }
-}
 /**
  * Node.js implementation using fs/promises
  */
@@ -176,99 +56,13 @@ class NodeFS {
         await nodeFs.access(path, mode);
     }
 }
-/**
- * Memory-based fallback for serverless/edge environments
- */
-class MemoryFS {
-    constructor() {
-        this.files = new Map();
-        this.dirs = new Set();
-    }
-    async readFile(path, encoding) {
-        const content = this.files.get(path);
-        if (content === undefined) {
-            throw new Error(`File not found: ${path}`);
-        }
-        return content;
-    }
-    async writeFile(path, data, encoding) {
-        this.files.set(path, data);
-        // Ensure parent directories exist
-        const parts = path.split('/').slice(0, -1);
-        for (let i = 1; i <= parts.length; i++) {
-            this.dirs.add(parts.slice(0, i).join('/'));
-        }
-    }
-    async mkdir(path, options = { recursive: true }) {
-        this.dirs.add(path);
-        if (options.recursive) {
-            const parts = path.split('/');
-            for (let i = 1; i <= parts.length; i++) {
-                this.dirs.add(parts.slice(0, i).join('/'));
-            }
-        }
-    }
-    async exists(path) {
-        return this.files.has(path) || this.dirs.has(path);
-    }
-    async readdir(path, options) {
-        const entries = new Set();
-        const pathPrefix = path + '/';
-        for (const filePath of this.files.keys()) {
-            if (filePath.startsWith(pathPrefix)) {
-                const relativePath = filePath.slice(pathPrefix.length);
-                const firstSegment = relativePath.split('/')[0];
-                entries.add(firstSegment);
-            }
-        }
-        for (const dirPath of this.dirs) {
-            if (dirPath.startsWith(pathPrefix)) {
-                const relativePath = dirPath.slice(pathPrefix.length);
-                const firstSegment = relativePath.split('/')[0];
-                if (firstSegment)
-                    entries.add(firstSegment);
-            }
-        }
-        if (options?.withFileTypes) {
-            return Array.from(entries).map(name => ({
-                name,
-                isDirectory: () => this.dirs.has(path + '/' + name),
-                isFile: () => this.files.has(path + '/' + name)
-            }));
-        }
-        return Array.from(entries);
-    }
-    async unlink(path) {
-        this.files.delete(path);
-    }
-    async stat(path) {
-        const isFile = this.files.has(path);
-        const isDir = this.dirs.has(path);
-        if (!isFile && !isDir) {
-            throw new Error(`Path not found: ${path}`);
-        }
-        return {
-            isFile: () => isFile,
-            isDirectory: () => isDir
-        };
-    }
-    async access(path, mode) {
-        const exists = await this.exists(path);
-        if (!exists) {
-            throw new Error(`ENOENT: no such file or directory, access '${path}'`);
-        }
-    }
-}
 // Create the appropriate filesystem implementation
 let fsImpl;
-if (isBrowser()) {
-    fsImpl = new BrowserFS();
-}
-else if (isNode() && nodeFs) {
+if (isNode() && nodeFs) {
     fsImpl = new NodeFS();
 }
 else {
-    fsImpl = new MemoryFS();
+    throw new Error('File system operations not available. Framework bundlers should provide fs polyfills or use storage adapters like OPFS, Memory, or S3.');
 }
 // Export the filesystem operations
 export const readFile = fsImpl.readFile.bind(fsImpl);

package/dist/universal/path.d.ts

@@ -1,10 +1,11 @@
 /**
  * Universal Path implementation
- * Browser: Manual path operations
- * Node.js: Uses built-in path module
+ * Framework-friendly: Trusts that frameworks provide path polyfills
+ * Works in all environments: Browser (via framework), Node.js, Serverless
  */
 /**
  * Universal path operations
+ * Framework-friendly: Assumes path API is available via framework polyfills
  */
 export declare function join(...paths: string[]): string;
 export declare function dirname(path: string): string;