@soulcraft/brainy 3.0.1 → 3.1.1

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;

package/dist/universal/path.js

@@ -1,7 +1,7 @@
 /**
  * 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
  */
 import { isNode } from '../utils/environment.js';
 let nodePath = null;
@@ -16,119 +16,63 @@ if (isNode()) {
 }
 /**
  * Universal path operations
+ * Framework-friendly: Assumes path API is available via framework polyfills
  */
 export function join(...paths) {
     if (nodePath) {
         return nodePath.join(...paths);
     }
-    // Browser fallback implementation
-    const parts = [];
-    for (const path of paths) {
-        if (path) {
-            parts.push(...path.split('/').filter(p => p));
-        }
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
     }
-    return parts.join('/');
 }
 export function dirname(path) {
     if (nodePath) {
         return nodePath.dirname(path);
     }
-    // Browser fallback implementation
-    const parts = path.split('/').filter(p => p);
-    if (parts.length <= 1)
-        return '.';
-    return parts.slice(0, -1).join('/');
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
+    }
 }
 export function basename(path, ext) {
     if (nodePath) {
         return nodePath.basename(path, ext);
     }
-    // Browser fallback implementation
-    const parts = path.split('/');
-    let name = parts[parts.length - 1];
-    if (ext && name.endsWith(ext)) {
-        name = name.slice(0, -ext.length);
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
     }
-    return name;
 }
 export function extname(path) {
     if (nodePath) {
         return nodePath.extname(path);
     }
-    // Browser fallback implementation
-    const name = basename(path);
-    const lastDot = name.lastIndexOf('.');
-    return lastDot === -1 ? '' : name.slice(lastDot);
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
+    }
 }
 export function resolve(...paths) {
     if (nodePath) {
         return nodePath.resolve(...paths);
     }
-    // Browser fallback implementation
-    let resolved = '';
-    let resolvedAbsolute = false;
-    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-        const path = i >= 0 ? paths[i] : '/';
-        if (!path)
-            continue;
-        resolved = path + '/' + resolved;
-        resolvedAbsolute = path.charAt(0) === '/';
-    }
-    // Normalize the path
-    resolved = normalizeArray(resolved.split('/').filter(p => p), !resolvedAbsolute).join('/');
-    return (resolvedAbsolute ? '/' : '') + resolved;
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
+    }
 }
 export function relative(from, to) {
     if (nodePath) {
         return nodePath.relative(from, to);
     }
-    // Browser fallback implementation
-    const fromParts = resolve(from).split('/').filter(p => p);
-    const toParts = resolve(to).split('/').filter(p => p);
-    let commonLength = 0;
-    for (let i = 0; i < Math.min(fromParts.length, toParts.length); i++) {
-        if (fromParts[i] === toParts[i]) {
-            commonLength++;
-        }
-        else {
-            break;
-        }
-    }
-    const upCount = fromParts.length - commonLength;
-    const upParts = new Array(upCount).fill('..');
-    const downParts = toParts.slice(commonLength);
-    return [...upParts, ...downParts].join('/');
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
+    }
 }
 export function isAbsolute(path) {
     if (nodePath) {
         return nodePath.isAbsolute(path);
     }
-    // Browser fallback implementation
-    return path.charAt(0) === '/';
-}
-/**
- * Normalize array helper function
- */
-function normalizeArray(parts, allowAboveRoot) {
-    const res = [];
-    for (let i = 0; i < parts.length; i++) {
-        const p = parts[i];
-        if (!p || p === '.')
-            continue;
-        if (p === '..') {
-            if (res.length && res[res.length - 1] !== '..') {
-                res.pop();
-            }
-            else if (allowAboveRoot) {
-                res.push('..');
-            }
-        }
-        else {
-            res.push(p);
-        }
-    }
-    return res;
+    else {
+        throw new Error('Path operations not available. Framework bundlers should provide path polyfills.');
+    }
 }
 // Path separator (always use forward slash for consistency)
 export const sep = '/';

package/dist/universal/uuid.d.ts

@@ -1,6 +1,6 @@
 /**
  * Universal UUID implementation
- * Works in all environments: Browser, Node.js, Serverless
+ * Framework-friendly: Works in all environments
  */
 export declare function v4(): string;
 export { v4 as uuidv4 };

package/dist/universal/uuid.js

@@ -1,6 +1,6 @@
 /**
  * Universal UUID implementation
- * Works in all environments: Browser, Node.js, Serverless
+ * Framework-friendly: Works in all environments
  */
 export function v4() {
     // Use crypto.randomUUID if available (Node.js 19+, modern browsers)

package/dist/utils/metadataIndex.js

@@ -1250,10 +1250,31 @@ export class MetadataIndexManager {
             const nounLimit = 25; // Even smaller batches during initialization to prevent socket exhaustion
             let hasMoreNouns = true;
             let totalNounsProcessed = 0;
-            while (hasMoreNouns) {
+            let consecutiveEmptyBatches = 0;
+            const MAX_ITERATIONS = 10000; // Safety limit to prevent infinite loops
+            let iterations = 0;
+            while (hasMoreNouns && iterations < MAX_ITERATIONS) {
+                iterations++;
                 const result = await this.storage.getNouns({
                     pagination: { offset: nounOffset, limit: nounLimit }
                 });
+                // CRITICAL SAFETY CHECK: Prevent infinite loop on empty results
+                if (result.items.length === 0) {
+                    consecutiveEmptyBatches++;
+                    if (consecutiveEmptyBatches >= 3) {
+                        prodLog.warn('⚠️ Breaking metadata rebuild loop: received 3 consecutive empty batches');
+                        break;
+                    }
+                    // If hasMore is true but items are empty, it's likely a bug
+                    if (result.hasMore) {
+                        prodLog.warn(`⚠️ Storage returned empty items but hasMore=true at offset ${nounOffset}`);
+                        hasMoreNouns = false; // Force exit
+                        break;
+                    }
+                }
+                else {
+                    consecutiveEmptyBatches = 0; // Reset counter on non-empty batch
+                }
                 // CRITICAL FIX: Use batch metadata reading to prevent socket exhaustion
                 const nounIds = result.items.map(noun => noun.id);
                 let metadataBatch;
@@ -1315,10 +1336,30 @@ export class MetadataIndexManager {
             const verbLimit = 25; // Even smaller batches during initialization to prevent socket exhaustion
             let hasMoreVerbs = true;
             let totalVerbsProcessed = 0;
-            while (hasMoreVerbs) {
+            let consecutiveEmptyVerbBatches = 0;
+            let verbIterations = 0;
+            while (hasMoreVerbs && verbIterations < MAX_ITERATIONS) {
+                verbIterations++;
                 const result = await this.storage.getVerbs({
                     pagination: { offset: verbOffset, limit: verbLimit }
                 });
+                // CRITICAL SAFETY CHECK: Prevent infinite loop on empty results
+                if (result.items.length === 0) {
+                    consecutiveEmptyVerbBatches++;
+                    if (consecutiveEmptyVerbBatches >= 3) {
+                        prodLog.warn('⚠️ Breaking verb metadata rebuild loop: received 3 consecutive empty batches');
+                        break;
+                    }
+                    // If hasMore is true but items are empty, it's likely a bug
+                    if (result.hasMore) {
+                        prodLog.warn(`⚠️ Storage returned empty verb items but hasMore=true at offset ${verbOffset}`);
+                        hasMoreVerbs = false; // Force exit
+                        break;
+                    }
+                }
+                else {
+                    consecutiveEmptyVerbBatches = 0; // Reset counter on non-empty batch
+                }
                 // CRITICAL FIX: Use batch verb metadata reading to prevent socket exhaustion
                 const verbIds = result.items.map(verb => verb.id);
                 let verbMetadataBatch;
@@ -1372,6 +1413,13 @@ export class MetadataIndexManager {
                 }
                 await this.yieldToEventLoop();
             }
+            // Check if we hit iteration limits
+            if (iterations >= MAX_ITERATIONS) {
+                prodLog.error(`❌ Metadata noun rebuild hit maximum iteration limit (${MAX_ITERATIONS}). This indicates a bug in storage pagination.`);
+            }
+            if (verbIterations >= MAX_ITERATIONS) {
+                prodLog.error(`❌ Metadata verb rebuild hit maximum iteration limit (${MAX_ITERATIONS}). This indicates a bug in storage pagination.`);
+            }
             // Flush to storage with final yield
             prodLog.debug('💾 Flushing metadata index to storage...');
             await this.flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -15,17 +15,8 @@
     "./src/setup.ts",
     "./src/utils/textEncoding.ts"
   ],
-  "browser": {
-    "fs": false,
-    "fs/promises": false,
-    "path": "path-browserify",
-    "crypto": "crypto-browserify",
-    "./dist/cortex/cortex.js": "./dist/browserFramework.js"
-  },
   "exports": {
     ".": {
-      "browser": "./dist/browserFramework.js",
-      "node": "./dist/index.js",
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
@@ -45,10 +36,6 @@
       "import": "./dist/utils/textEncoding.js",
       "types": "./dist/utils/textEncoding.d.ts"
     },
-    "./browserFramework": {
-      "import": "./dist/browserFramework.js",
-      "types": "./dist/browserFramework.d.ts"
-    },
     "./universal": {
       "import": "./dist/universal/index.js",
       "types": "./dist/universal/index.d.ts"

package/dist/browserFramework.d.ts

@@ -1,15 +0,0 @@
-/**
- * Browser Framework Entry Point for Brainy
- * Optimized for modern frameworks like Angular, React, Vue, etc.
- * Auto-detects environment and uses optimal storage (OPFS in browsers)
- */
-import { Brainy, BrainyConfig } from './brainy.js';
-import { VerbType, NounType } from './types/graphTypes.js';
-/**
- * Create a Brainy instance optimized for browser frameworks
- * Auto-detects environment and selects optimal storage and settings
- */
-export declare function createBrowserBrainy(config?: Partial<BrainyConfig>): Promise<Brainy>;
-export { VerbType, NounType, Brainy };
-export type { BrainyConfig };
-export default createBrowserBrainy;