@soulcraft/brainy 0.9.12 → 0.9.13

package/dist/index.d.ts

@@ -8,7 +8,8 @@ export type { BrainyDataConfig };
 import { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistance } from './utils/index.js';
 export { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistance };
 import { UniversalSentenceEncoder, createEmbeddingFunction, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction } from './utils/embedding.js';
-export { UniversalSentenceEncoder, createEmbeddingFunction, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction };
+import { executeInThread, cleanupWorkerPools } from './utils/workerUtils.js';
+export { UniversalSentenceEncoder, createEmbeddingFunction, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction, executeInThread, cleanupWorkerPools };
 import { OPFSStorage, MemoryStorage, createStorage } from './storage/opfsStorage.js';
 import { FileSystemStorage } from './storage/fileSystemStorage.js';
 import { R2Storage, S3CompatibleStorage } from './storage/s3CompatibleStorage.js';

package/dist/unified.js

@@ -2670,33 +2670,213 @@ async function calculateDistancesBatch(queryVector, vectors, distanceFunction =
 }
 
 /**
- * Utility functions for executing functions (without Web Workers or Worker Threads)
- * This is a replacement for the original multithreaded implementation
+ * Utility functions for environment detection
+ */
+/**
+ * Check if code is running in a browser environment
+ */
+function isBrowser$1() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/**
+ * Check if code is running in a Node.js environment
+ */
+function isNode() {
+    return typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null;
+}
+/**
+ * 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)
+ */
+function areWorkerThreadsAvailable() {
+    if (!isNode())
+        return false;
+    try {
+        // Dynamic import to avoid errors in browser environments
+        require('worker_threads');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Determine if threading is available in the current environment
+ * Returns true if either Web Workers (browser) or Worker Threads (Node.js) are available
+ */
+function isThreadingAvailable() {
+    return areWebWorkersAvailable() || areWorkerThreadsAvailable();
+}
+
+/**
+ * Utility functions for executing functions in Worker Threads (Node.js) or Web Workers (Browser)
+ * This implementation leverages Node.js 24's improved Worker Threads API for better performance
  */
+// Worker pool to reuse workers
+const workerPool = new Map();
+const MAX_POOL_SIZE = 4; // Adjust based on system capabilities
 /**
- * Execute a function directly in the main thread
+ * Execute a function in a separate thread
  *
  * @param fnString The function to execute as a string
  * @param args The arguments to pass to the function
  * @returns A promise that resolves with the result of the function
  */
 function executeInThread(fnString, args) {
-    try {
-        // Parse the function from string and execute it
-        const fn = new Function('return ' + fnString)();
-        return Promise.resolve(fn(args));
+    if (isNode()) {
+        return executeInNodeWorker(fnString, args);
     }
-    catch (error) {
-        return Promise.reject(error);
+    else if (isBrowser$1() && typeof window !== 'undefined' && window.Worker) {
+        return executeInWebWorker(fnString, args);
     }
+    else {
+        // Fallback to main thread execution
+        try {
+            const fn = new Function('return ' + fnString)();
+            return Promise.resolve(fn(args));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+/**
+ * Execute a function in a Node.js Worker Thread
+ * Optimized for Node.js 24 with improved Worker Threads performance
+ */
+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 }) => {
+                if (!isMainThread && parentPort) {
+                    // We're inside a worker, execute the function
+                    const fn = new Function('return ' + workerData.fnString)();
+                    const result = fn(workerData.args);
+                    parentPort.postMessage({ result });
+                    return;
+                }
+                // Get a worker from the pool or create a new one
+                const workerId = `worker-${Math.random().toString(36).substring(2, 9)}`;
+                let worker;
+                if (workerPool.size < MAX_POOL_SIZE) {
+                    // Create a new worker
+                    worker = new Worker(`
+            import { parentPort, workerData } from 'node:worker_threads';
+            const fn = new Function('return ' + workerData.fnString)();
+            const result = fn(workerData.args);
+            parentPort.postMessage({ result });
+          `, {
+                        eval: true,
+                        workerData: { fnString, args }
+                    });
+                    workerPool.set(workerId, worker);
+                }
+                else {
+                    // Reuse an existing worker
+                    const poolKeys = Array.from(workerPool.keys());
+                    const randomKey = poolKeys[Math.floor(Math.random() * poolKeys.length)];
+                    worker = workerPool.get(randomKey);
+                    // Terminate and recreate if the worker is busy
+                    if (worker._busy) {
+                        worker.terminate();
+                        worker = new Worker(`
+              import { parentPort, workerData } from 'node:worker_threads';
+              const fn = new Function('return ' + workerData.fnString)();
+              const result = fn(workerData.args);
+              parentPort.postMessage({ result });
+            `, {
+                            eval: true,
+                            workerData: { fnString, args }
+                        });
+                        workerPool.set(randomKey, worker);
+                    }
+                    worker._busy = true;
+                }
+                worker.on('message', (message) => {
+                    worker._busy = false;
+                    resolve(message.result);
+                });
+                worker.on('error', (err) => {
+                    worker._busy = false;
+                    reject(err);
+                });
+                worker.on('exit', (code) => {
+                    if (code !== 0) {
+                        worker._busy = false;
+                        reject(new Error(`Worker stopped with exit code ${code}`));
+                    }
+                });
+            }).catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+/**
+ * Execute a function in a Web Worker (Browser environment)
+ */
+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);
+            worker.onmessage = function (e) {
+                if (e.data.error) {
+                    reject(new Error(e.data.error));
+                }
+                else {
+                    resolve(e.data.result);
+                }
+                worker.terminate();
+                URL.revokeObjectURL(url);
+            };
+            worker.onerror = function (e) {
+                reject(new Error(`Worker error: ${e.message}`));
+                worker.terminate();
+                URL.revokeObjectURL(url);
+            };
+            worker.postMessage({ fnString, args });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
 }
 /**
- * No-op function for backward compatibility
- * This function does nothing since there are no worker pools to clean up
+ * Clean up all worker pools
+ * This should be called when the application is shutting down
  */
 function cleanupWorkerPools() {
-    // No-op function
-    console.log('Worker pools cleanup called (no-op in non-threaded version)');
+    if (isNode()) {
+        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);
+    }
 }
 
 /**
@@ -10854,31 +11034,6 @@ var s3CompatibleStorage = /*#__PURE__*/Object.freeze({
 	S3CompatibleStorage: S3CompatibleStorage
 });
 
-/**
- * Utility functions for environment detection
- */
-/**
- * Check if code is running in a browser environment
- */
-function isBrowser$1() {
-    return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-/**
- * Check if code is running in a Node.js environment
- */
-function isNode() {
-    return typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null;
-}
-/**
- * Determine if threading is available in the current environment
- * Always returns false since multithreading has been removed
- */
-function isThreadingAvailable() {
-    return false;
-}
-
 /**
  * Augmentation Registry
  *
@@ -87034,5 +87189,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, cosineDistance$1 as cosineDistance, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin, createConduitAugmentation, createEmbeddingFunction, createMemoryAugmentation, createPipeline, createSenseAugmentation, createServerSearchAugmentations, createStorage, createStreamingPipeline, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction, dotProductDistance, environment, euclideanDistance, executeAugmentation, executeByType, 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, 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 };
 //# sourceMappingURL=unified.js.map