@soulcraft/brainy 0.9.36 → 0.10.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.9.37] - 2025-07-04
+
+**Full Changelog**: https://github.com/soulcraft-research/brainy/compare/v0.9.36...v0.9.37
+
+## [0.9.36] - 2025-07-04
+
+**Full Changelog**: https://github.com/soulcraft-research/brainy/commits/v0.9.36
+
 ## [0.9.34] - 2024-07-01
 
 This is the initial changelog entry. Future releases will automatically update this file with release notes from GitHub.

package/README.md

@@ -6,7 +6,7 @@
 [![Node.js](https://img.shields.io/badge/node-%3E%3D24.3.0-brightgreen.svg)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.4.5-blue.svg)](https://www.typescriptlang.org/)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
-[![npm](https://img.shields.io/badge/npm-v0.9.36-blue.svg)](https://www.npmjs.com/package/@soulcraft/brainy)
+[![npm](https://img.shields.io/badge/npm-v0.10.0-blue.svg)](https://www.npmjs.com/package/@soulcraft/brainy)
 
 [//]: # ([![Cartographer](https://img.shields.io/badge/Cartographer-Official%20Standard-brightgreen)](https://github.com/sodal-project/cartographer))
 

package/dist/augmentationFactory.d.ts

@@ -84,4 +84,3 @@ export declare function loadAugmentationModule(modulePromise: Promise<any>, opti
     autoRegister?: boolean;
     autoInitialize?: boolean;
 }): Promise<IAugmentation[]>;
-//# sourceMappingURL=augmentationFactory.d.ts.map

package/dist/augmentationPipeline.d.ts

@@ -202,4 +202,3 @@ export declare class AugmentationPipeline {
     private executeTypedPipeline;
 }
 export declare const augmentationPipeline: AugmentationPipeline;
-//# sourceMappingURL=augmentationPipeline.d.ts.map

package/dist/augmentationRegistry.d.ts

@@ -45,4 +45,3 @@ export declare function setAugmentationEnabled(name: string, enabled: boolean):
  * @returns An array of all augmentations of the specified type
  */
 export declare function getAugmentationsByType(type: AugmentationType): IAugmentation[];
-//# sourceMappingURL=augmentationRegistry.d.ts.map

package/dist/augmentationRegistryLoader.d.ts

@@ -144,4 +144,3 @@ export declare function createAugmentationRegistryRollupPlugin(options: {
     pattern: RegExp;
     options: AugmentationRegistryLoaderOptions;
 };
-//# sourceMappingURL=augmentationRegistryLoader.d.ts.map

package/dist/augmentations/conduitAugmentations.d.ts

@@ -170,4 +170,3 @@ export declare class WebRTCConduitAugmentation extends BaseConduitAugmentation i
  */
 export declare function createConduitAugmentation(type: 'websocket' | 'webrtc', name?: string, options?: Record<string, unknown>): Promise<IConduitAugmentation & IWebSocketSupport>;
 export {};
-//# sourceMappingURL=conduitAugmentations.d.ts.map

package/dist/augmentations/memoryAugmentations.d.ts

@@ -68,4 +68,3 @@ export declare function createMemoryAugmentation(name: string, options?: {
     requestPersistentStorage?: boolean;
 }): Promise<IMemoryAugmentation>;
 export {};
-//# sourceMappingURL=memoryAugmentations.d.ts.map

package/dist/augmentations/serverSearchAugmentations.d.ts

@@ -165,4 +165,3 @@ export declare function createServerSearchAugmentations(serverUrl: string, optio
     activation: ServerSearchActivationAugmentation;
     connection: WebSocketConnection;
 }>;
-//# sourceMappingURL=serverSearchAugmentations.d.ts.map

package/dist/brainy.js

@@ -2396,6 +2396,137 @@ ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 	} 
 } (buffer$1));
 
+/**
+ * Unified Text Encoding Utilities
+ *
+ * This module provides a consistent way to handle text encoding/decoding across all environments
+ * without relying on TextEncoder/TextDecoder polyfills or patches.
+ */
+/**
+ * A simple text encoder that works in all environments
+ * This avoids the need for TextEncoder polyfills and patches
+ */
+class SimpleTextEncoder {
+    /**
+     * Encode a string to a Uint8Array
+     * @param input - The string to encode
+     * @returns A Uint8Array containing the encoded string
+     */
+    encode(input) {
+        // Simple UTF-8 encoding implementation that works everywhere
+        return new Uint8Array([...input].map((c) => c.charCodeAt(0)));
+    }
+}
+/**
+ * A simple text decoder that works in all environments
+ * This avoids the need for TextDecoder polyfills and patches
+ */
+class SimpleTextDecoder {
+    /**
+     * Decode a Uint8Array to a string
+     * @param input - The Uint8Array to decode
+     * @returns The decoded string
+     */
+    decode(input) {
+        // Simple UTF-8 decoding implementation that works everywhere
+        return String.fromCharCode.apply(null, [...input]);
+    }
+}
+/**
+ * A constructor function for TextEncoder that works in all environments
+ */
+function UniversalTextEncoder() {
+    if (!(this instanceof UniversalTextEncoder)) {
+        return new UniversalTextEncoder();
+    }
+    try {
+        // Try to use the native TextEncoder if available
+        const nativeEncoder = new TextEncoder();
+        this.encode = nativeEncoder.encode.bind(nativeEncoder);
+    }
+    catch (e) {
+        // Fall back to our simple implementation
+        const simpleEncoder = new SimpleTextEncoder();
+        this.encode = simpleEncoder.encode.bind(simpleEncoder);
+    }
+}
+/**
+ * A constructor function for TextDecoder that works in all environments
+ */
+function UniversalTextDecoder() {
+    if (!(this instanceof UniversalTextDecoder)) {
+        return new UniversalTextDecoder();
+    }
+    try {
+        // Try to use the native TextDecoder if available
+        const nativeDecoder = new TextDecoder();
+        this.decode = nativeDecoder.decode.bind(nativeDecoder);
+    }
+    catch (e) {
+        // Fall back to our simple implementation
+        const simpleDecoder = new SimpleTextDecoder();
+        this.decode = simpleDecoder.decode.bind(simpleDecoder);
+    }
+}
+/**
+ * Get a text encoder that works in the current environment
+ * @returns A text encoder object with an encode method
+ */
+function getTextEncoder() {
+    return new UniversalTextEncoder();
+}
+/**
+ * Get a text decoder that works in the current environment
+ * @returns A text decoder object with a decode method
+ */
+function getTextDecoder() {
+    return new UniversalTextDecoder();
+}
+/**
+ * Apply the TensorFlow.js platform patch if needed
+ * This function patches the global object to provide a PlatformNode class
+ * that uses our text encoding utilities instead of relying on TextEncoder/TextDecoder
+ */
+function applyTensorFlowPatch() {
+    // Only apply in Node.js environment
+    if (typeof global !== 'undefined' &&
+        typeof process !== 'undefined' &&
+        process.versions &&
+        process.versions.node) {
+        try {
+            // Get encoders/decoders
+            const encoder = getTextEncoder();
+            const decoder = getTextDecoder();
+            // Define a custom PlatformNode class
+            class PlatformNode {
+                constructor() {
+                    // Create a util object with necessary methods and constructors
+                    this.util = {
+                        isFloat32Array: (arr) => !!(arr instanceof Float32Array ||
+                            (arr &&
+                                Object.prototype.toString.call(arr) ===
+                                    '[object Float32Array]')),
+                        isTypedArray: (arr) => !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView)),
+                        // Add TextEncoder and TextDecoder as constructors
+                        TextEncoder: UniversalTextEncoder,
+                        TextDecoder: UniversalTextDecoder
+                    };
+                    // Initialize using the constructors from util
+                    this.textEncoder = new this.util.TextEncoder();
+                    this.textDecoder = new this.util.TextDecoder();
+                }
+            }
+            // Assign the PlatformNode class to the global object
+            ;
+            global.PlatformNode = PlatformNode;
+            global.platformNode = new PlatformNode();
+        }
+        catch (error) {
+            console.warn('Failed to apply TensorFlow.js platform patch:', error);
+        }
+    }
+}
+
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number
 // generators (like Math.random()).
@@ -2688,12 +2819,35 @@ function isNode() {
         process.versions != null &&
         process.versions.node != null);
 }
+/**
+ * Check if code is running in a Web Worker environment
+ */
+function isWebWorker() {
+    return (typeof self === 'object' &&
+        self.constructor &&
+        self.constructor.name === 'DedicatedWorkerGlobalScope');
+}
 /**
  * Check if Web Workers are available in the current environment
  */
 function areWebWorkersAvailable() {
     return isBrowser$1() && typeof Worker !== 'undefined';
 }
+/**
+ * Check if Worker Threads are available in the current environment (Node.js)
+ */
+async function areWorkerThreadsAvailable() {
+    if (!isNode())
+        return false;
+    try {
+        // Use dynamic import to avoid errors in browser environments
+        await import('worker_threads');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
 /**
  * Synchronous version that doesn't actually try to load the module
  * This is safer in ES module environments
@@ -2711,6 +2865,12 @@ function areWorkerThreadsAvailableSync() {
 function isThreadingAvailable() {
     return areWebWorkersAvailable() || areWorkerThreadsAvailableSync();
 }
+/**
+ * Async version of isThreadingAvailable
+ */
+async function isThreadingAvailableAsync() {
+    return areWebWorkersAvailable() || (await areWorkerThreadsAvailable());
+}
 
 /**
  * Utility functions for executing functions in Worker Threads (Node.js) or Web Workers (Browser)
@@ -2736,7 +2896,31 @@ function executeInThread(fnString, args) {
     else {
         // Fallback to main thread execution
         try {
-            const fn = new Function('return ' + fnString)();
+            // Try different approaches to create a function from string
+            let fn;
+            try {
+                // First try with 'return' prefix
+                fn = new Function('return ' + fnString)();
+            }
+            catch (functionError) {
+                console.warn('Fallback: Error creating function with return syntax, trying alternative approaches', functionError);
+                try {
+                    // Try wrapping in parentheses for function expressions
+                    fn = new Function('return (' + fnString + ')')();
+                }
+                catch (wrapError) {
+                    console.warn('Fallback: Error creating function with parentheses wrapping', wrapError);
+                    try {
+                        // Try direct approach for named functions
+                        fn = new Function(fnString)();
+                    }
+                    catch (directError) {
+                        console.error('Fallback: All approaches to create function failed', directError);
+                        throw new Error('Failed to create function from string: ' +
+                            functionError.message);
+                    }
+                }
+            }
             return Promise.resolve(fn(args));
         }
         catch (error) {
@@ -2752,7 +2936,8 @@ function executeInNodeWorker(fnString, args) {
     return new Promise((resolve, reject) => {
         try {
             // Dynamically import worker_threads (Node.js only)
-            import('node:worker_threads').then(({ Worker, isMainThread, parentPort, workerData }) => {
+            import('node:worker_threads')
+                .then(({ Worker, isMainThread, parentPort, workerData }) => {
                 if (!isMainThread && parentPort) {
                     // We're inside a worker, execute the function
                     const fn = new Function('return ' + workerData.fnString)();
@@ -2811,7 +2996,8 @@ function executeInNodeWorker(fnString, args) {
                         reject(new Error(`Worker stopped with exit code ${code}`));
                     }
                 });
-            }).catch(reject);
+            })
+                .catch(reject);
         }
         catch (error) {
             reject(error);
@@ -2824,21 +3010,131 @@ function executeInNodeWorker(fnString, args) {
 function executeInWebWorker(fnString, args) {
     return new Promise((resolve, reject) => {
         try {
-            const workerCode = `
-        self.onmessage = function(e) {
-          try {
-            const fn = new Function('return ' + e.data.fnString)();
-            const result = fn(e.data.args);
-            self.postMessage({ result: result });
-          } catch (error) {
-            self.postMessage({ error: error.message });
-          }
-        };
-      `;
-            const blob = new Blob([workerCode], { type: 'application/javascript' });
-            const url = URL.createObjectURL(blob);
-            const worker = new Worker(url);
+            // Use the dedicated worker.js file instead of creating a blob
+            // Try different approaches to locate the worker.js file
+            let workerPath = './worker.js';
+            try {
+                // First try to use the import.meta.url if available (modern browsers)
+                if (typeof import.meta !== 'undefined' && import.meta.url) {
+                    const baseUrl = import.meta.url.substring(0, import.meta.url.lastIndexOf('/') + 1);
+                    workerPath = `${baseUrl}worker.js`;
+                }
+                // Fallback to a relative path based on the unified.js location
+                else if (typeof document !== 'undefined') {
+                    // Find the script tag that loaded unified.js
+                    const scripts = document.getElementsByTagName('script');
+                    for (let i = 0; i < scripts.length; i++) {
+                        const src = scripts[i].src;
+                        if (src && src.includes('unified.js')) {
+                            // Get the directory path
+                            workerPath =
+                                src.substring(0, src.lastIndexOf('/') + 1) + 'worker.js';
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.warn('Could not determine worker path from import.meta.url, using relative path', e);
+            }
+            // If we couldn't determine the path, try some common locations
+            if (workerPath === './worker.js' && typeof window !== 'undefined') {
+                // Try to find the worker.js in the same directory as the current page
+                const pageUrl = window.location.href;
+                const pageDir = pageUrl.substring(0, pageUrl.lastIndexOf('/') + 1);
+                workerPath = `${pageDir}worker.js`;
+                // Also check for dist/worker.js
+                if (typeof document !== 'undefined') {
+                    const distWorkerPath = `${pageDir}dist/worker.js`;
+                    // Create a test request to see if the file exists
+                    const xhr = new XMLHttpRequest();
+                    xhr.open('HEAD', distWorkerPath, false);
+                    try {
+                        xhr.send();
+                        if (xhr.status >= 200 && xhr.status < 300) {
+                            workerPath = distWorkerPath;
+                        }
+                    }
+                    catch (e) {
+                        // Ignore errors, we'll use the default path
+                    }
+                }
+            }
+            console.log('Using worker path:', workerPath);
+            // Try to create a worker, but fall back to inline worker or main thread execution if it fails
+            let worker;
+            try {
+                worker = new Worker(workerPath);
+            }
+            catch (error) {
+                console.warn('Failed to create Web Worker from file, trying inline worker:', error);
+                try {
+                    // Create an inline worker using a Blob
+                    const workerCode = `
+            // Brainy Inline Worker Script
+            console.log('Brainy Inline Worker: Started');
+
+            self.onmessage = function (e) {
+              try {
+                console.log('Brainy Inline Worker: Received message', e.data ? 'with data' : 'without data');
+
+                if (!e.data || !e.data.fnString) {
+                  throw new Error('Invalid message: missing function string');
+                }
+
+                console.log('Brainy Inline Worker: Creating function from string');
+                const fn = new Function('return ' + e.data.fnString)();
+
+                console.log('Brainy Inline Worker: Executing function with args');
+                const result = fn(e.data.args);
+
+                console.log('Brainy Inline Worker: Function executed successfully, posting result');
+                self.postMessage({ result: result });
+              } catch (error) {
+                console.error('Brainy Inline Worker: Error executing function', error);
+                self.postMessage({ 
+                  error: error.message,
+                  stack: error.stack
+                });
+              }
+            };
+          `;
+                    const blob = new Blob([workerCode], {
+                        type: 'application/javascript'
+                    });
+                    const blobUrl = URL.createObjectURL(blob);
+                    worker = new Worker(blobUrl);
+                    console.log('Created inline worker using Blob URL');
+                }
+                catch (inlineWorkerError) {
+                    console.warn('Failed to create inline Web Worker, falling back to main thread execution:', inlineWorkerError);
+                    // Execute in main thread as fallback
+                    try {
+                        const fn = new Function('return ' + fnString)();
+                        resolve(fn(args));
+                        return;
+                    }
+                    catch (mainThreadError) {
+                        reject(mainThreadError);
+                        return;
+                    }
+                }
+            }
+            // Set a timeout to prevent hanging
+            const timeoutId = setTimeout(() => {
+                console.warn('Web Worker execution timed out, falling back to main thread');
+                worker.terminate();
+                // Execute in main thread as fallback
+                try {
+                    const fn = new Function('return ' + fnString)();
+                    resolve(fn(args));
+                }
+                catch (mainThreadError) {
+                    reject(mainThreadError);
+                }
+            }, 25000); // 25 second timeout (less than the 30 second test timeout)
             worker.onmessage = function (e) {
+                clearTimeout(timeoutId);
                 if (e.data.error) {
                     reject(new Error(e.data.error));
                 }
@@ -2846,12 +3142,19 @@ function executeInWebWorker(fnString, args) {
                     resolve(e.data.result);
                 }
                 worker.terminate();
-                URL.revokeObjectURL(url);
             };
             worker.onerror = function (e) {
-                reject(new Error(`Worker error: ${e.message}`));
+                clearTimeout(timeoutId);
+                console.warn('Web Worker error, falling back to main thread execution:', e.message);
                 worker.terminate();
-                URL.revokeObjectURL(url);
+                // Execute in main thread as fallback
+                try {
+                    const fn = new Function('return ' + fnString)();
+                    resolve(fn(args));
+                }
+                catch (mainThreadError) {
+                    reject(mainThreadError);
+                }
             };
             worker.postMessage({ fnString, args });
         }
@@ -2866,13 +3169,15 @@ function executeInWebWorker(fnString, args) {
  */
 function cleanupWorkerPools() {
     if (isNode()) {
-        import('node:worker_threads').then(({ Worker }) => {
+        import('node:worker_threads')
+            .then(({ Worker }) => {
             for (const worker of workerPool.values()) {
                 worker.terminate();
             }
             workerPool.clear();
             console.log('Worker pools cleaned up');
-        }).catch(console.error);
+        })
+            .catch(console.error);
     }
 }
 
@@ -13890,15 +14195,20 @@ class BrainyMCPService {
     }
 }
 
+/**
+ * OPFS BrainyData
+ * A vector database using HNSW indexing with Origin Private File System storage
+ */
+// Import unified text encoding utilities first to ensure they're available
+// Apply the TensorFlow.js platform patch if needed
+applyTensorFlowPatch();
+
 // Make Buffer available globally
 if (typeof window !== 'undefined' && typeof globalThis.Buffer === 'undefined') {
   globalThis.Buffer = buffer$1.Buffer;
 }
-/**
- * Unified entry point for Brainy
- * This file exports everything from index.ts
- * Environment detection is handled here and made available to all components
- */
+// Apply the TensorFlow.js platform patch if needed
+applyTensorFlowPatch();
 // Export environment information
 const environment = {
     isBrowser: typeof window !== 'undefined',
@@ -87227,5 +87537,5 @@ var _child_processShim = /*#__PURE__*/Object.freeze({
 	__proto__: null
 });
 
-export { AugmentationType, BrainyData, BrainyMCPAdapter, BrainyMCPService, ExecutionMode$1 as ExecutionMode, FileSystemStorage, FileSystemStorageAugmentation, HNSWIndex, HNSWIndexOptimized, MCPAugmentationToolset, MCPRequestType, MCP_VERSION, MemoryStorage, MemoryStorageAugmentation, NounType, OPFSStorage, OPFSStorageAugmentation, Pipeline, S3CompatibleStorage as R2Storage, S3CompatibleStorage, SequentialPipeline, ServerSearchActivationAugmentation, ServerSearchConduitAugmentation, StreamlinedExecutionMode, UniversalSentenceEncoder$1 as UniversalSentenceEncoder, VerbType, WebRTCConduitAugmentation, WebSocketConduitAugmentation, addWebSocketSupport, augmentationPipeline$1 as augmentationPipeline, availableAugmentations, cleanupWorkerPools, cosineDistance$1 as cosineDistance, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin, createConduitAugmentation, createEmbeddingFunction, createMemoryAugmentation, createPipeline, createSenseAugmentation, createServerSearchAugmentations, createStorage, createStreamingPipeline, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction, dotProductDistance, environment, euclideanDistance, executeAugmentation, executeByType, executeInThread, executeSingle, executeStreamlined, getAugmentationsByType, initializeAugmentationPipeline, loadAugmentationModule, loadAugmentationsFromModules, manhattanDistance, pipeline, processStaticData, processStreamingData, registerAugmentation, sequentialPipeline, setAugmentationEnabled };
+export { AugmentationType, BrainyData, BrainyMCPAdapter, BrainyMCPService, ExecutionMode$1 as ExecutionMode, FileSystemStorage, FileSystemStorageAugmentation, HNSWIndex, HNSWIndexOptimized, MCPAugmentationToolset, MCPRequestType, MCP_VERSION, MemoryStorage, MemoryStorageAugmentation, NounType, OPFSStorage, OPFSStorageAugmentation, Pipeline, S3CompatibleStorage as R2Storage, S3CompatibleStorage, SequentialPipeline, ServerSearchActivationAugmentation, ServerSearchConduitAugmentation, StreamlinedExecutionMode, UniversalSentenceEncoder$1 as UniversalSentenceEncoder, VerbType, WebRTCConduitAugmentation, WebSocketConduitAugmentation, addWebSocketSupport, areWebWorkersAvailable, areWorkerThreadsAvailable, areWorkerThreadsAvailableSync, augmentationPipeline$1 as augmentationPipeline, availableAugmentations, cleanupWorkerPools, cosineDistance$1 as cosineDistance, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin, createConduitAugmentation, createEmbeddingFunction, createMemoryAugmentation, createPipeline, createSenseAugmentation, createServerSearchAugmentations, createStorage, createStreamingPipeline, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction, dotProductDistance, environment, euclideanDistance, executeAugmentation, executeByType, executeInThread, executeSingle, executeStreamlined, getAugmentationsByType, initializeAugmentationPipeline, isBrowser$1 as isBrowser, isNode, isThreadingAvailable, isThreadingAvailableAsync, isWebWorker, loadAugmentationModule, loadAugmentationsFromModules, manhattanDistance, pipeline, processStaticData, processStreamingData, registerAugmentation, sequentialPipeline, setAugmentationEnabled };
 //# sourceMappingURL=brainy.js.map