@soulcraft/brainy 0.9.5 → 0.9.7

package/dist/brainy.js

@@ -2524,6 +2524,177 @@ const dotProductDistance = (a, b) => {
     return -dotProduct;
 };
 
+/**
+ * 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
+ */
+function isThreadingAvailable() {
+    return areWebWorkersAvailable() || areWorkerThreadsAvailable();
+}
+
+/**
+ * Utility functions for working with Web Workers and Worker Threads
+ */
+/**
+ * Execute a function in a Web Worker (browser environment)
+ *
+ * @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 executeInWebWorker(fnString, args) {
+    return new Promise((resolve, reject) => {
+        // Create a blob URL for the worker script
+        const workerScript = `
+      self.onmessage = async function(e) {
+        try {
+          const fn = ${fnString};
+          const result = await fn(e.data);
+          self.postMessage({ success: true, data: result });
+        } catch (error) {
+          self.postMessage({ 
+            success: false, 
+            error: error instanceof Error ? error.message : String(error) 
+          });
+        }
+      };
+    `;
+        const blob = new Blob([workerScript], { type: 'application/javascript' });
+        const blobURL = URL.createObjectURL(blob);
+        // Create a worker
+        const worker = new Worker(blobURL);
+        // Set up message handling
+        worker.onmessage = function (e) {
+            URL.revokeObjectURL(blobURL); // Clean up
+            worker.terminate(); // Terminate the worker
+            if (e.data.success) {
+                resolve(e.data.data);
+            }
+            else {
+                reject(new Error(e.data.error));
+            }
+        };
+        worker.onerror = function (error) {
+            URL.revokeObjectURL(blobURL); // Clean up
+            worker.terminate(); // Terminate the worker
+            reject(error);
+        };
+        // Start the worker
+        worker.postMessage(args);
+    });
+}
+/**
+ * Execute a function in a Worker Thread (Node.js environment)
+ *
+ * @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 executeInWorkerThread(fnString, args) {
+    return new Promise((resolve, reject) => {
+        try {
+            // Dynamic import to avoid errors in browser environments
+            const { Worker } = require('worker_threads');
+            // Create a worker script
+            const workerScript = `
+        const { parentPort } = require('worker_threads');
+
+        parentPort.once('message', async (data) => {
+          try {
+            const fn = ${fnString};
+            const result = await fn(data);
+            parentPort.postMessage({ success: true, data: result });
+          } catch (error) {
+            parentPort.postMessage({ 
+              success: false, 
+              error: error instanceof Error ? error.message : String(error) 
+            });
+          }
+        });
+      `;
+            // Create a worker
+            const worker = new Worker(workerScript, { eval: true });
+            // Set up message handling
+            worker.on('message', (data) => {
+                worker.terminate(); // Terminate the worker
+                if (data.success) {
+                    resolve(data.data);
+                }
+                else {
+                    reject(new Error(data.error));
+                }
+            });
+            worker.on('error', (error) => {
+                worker.terminate(); // Terminate the worker
+                reject(error);
+            });
+            // Start the worker
+            worker.postMessage(args);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+/**
+ * Execute a function in a separate thread based on the environment
+ *
+ * @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) {
+    if (isBrowser$1()) {
+        return executeInWebWorker(fnString, args);
+    }
+    else if (isNode()) {
+        return executeInWorkerThread(fnString, args);
+    }
+    else {
+        // Fall back to executing in the main thread
+        // Parse the function from string and execute it
+        const fn = new Function('return ' + fnString)();
+        return Promise.resolve(fn(args));
+    }
+}
+
 /**
  * Embedding functions for converting data to vectors
  */
@@ -2687,12 +2858,89 @@ function createTensorFlowEmbeddingFunction() {
         }
     };
 }
+/**
+ * Creates a TensorFlow-based Universal Sentence Encoder embedding function that runs in a separate thread
+ * This provides better performance for CPU-intensive embedding operations
+ * @param options Configuration options
+ * @returns An embedding function that runs in a separate thread
+ */
+function createThreadedEmbeddingFunction(options = {}) {
+    // Create a standard embedding function to use as fallback
+    const standardEmbedding = createTensorFlowEmbeddingFunction();
+    // Flag to track if we've fallen back to main thread
+    let useFallback = false;
+    return async (data) => {
+        // If we've already determined that threading doesn't work, use the fallback
+        if (useFallback) {
+            return standardEmbedding(data);
+        }
+        try {
+            // Function to be executed in a worker thread
+            // This must be a regular function (not async) to avoid Promise cloning issues
+            const embedInWorker = (inputData) => {
+                // Return a plain object with the input data
+                // All async operations will be performed inside the worker
+                return { data: inputData };
+            };
+            // Worker implementation function that will be stringified and run in the worker
+            const workerImplementation = async ({ data }) => {
+                // We need to dynamically import TensorFlow.js and USE in the worker
+                const tf = await Promise.resolve().then(function () { return index; });
+                const use = await Promise.resolve().then(function () { return universalSentenceEncoder_esm; });
+                // Load the model
+                const model = await use.load();
+                // Handle different input types
+                let textToEmbed;
+                if (typeof data === 'string') {
+                    if (data.trim() === '') {
+                        return new Array(512).fill(0);
+                    }
+                    textToEmbed = [data];
+                }
+                else if (Array.isArray(data) &&
+                    data.every((item) => typeof item === 'string')) {
+                    if (data.length === 0 || data.every((item) => item.trim() === '')) {
+                        return new Array(512).fill(0);
+                    }
+                    textToEmbed = data.filter((item) => item.trim() !== '');
+                    if (textToEmbed.length === 0) {
+                        return new Array(512).fill(0);
+                    }
+                }
+                else {
+                    throw new Error('UniversalSentenceEncoder only supports string or string[] data');
+                }
+                // Get embeddings
+                const embeddings = await model.embed(textToEmbed);
+                // Convert to array and return the first embedding
+                const embeddingArray = await embeddings.array();
+                // Dispose of the tensor to free memory
+                embeddings.dispose();
+                return embeddingArray[0];
+            };
+            // Execute the embedding function in a separate thread
+            // Pass the worker implementation as a string to avoid Promise cloning issues
+            return await executeInThread(workerImplementation.toString(), embedInWorker(data));
+        }
+        catch (error) {
+            // If threading fails and fallback is enabled, use the standard embedding function
+            if (options.fallbackToMain) {
+                console.warn('Threaded embedding failed, falling back to main thread:', error);
+                useFallback = true;
+                return standardEmbedding(data);
+            }
+            // Otherwise, propagate the error
+            throw new Error(`Threaded embedding failed: ${error}`);
+        }
+    };
+}
 /**
  * Default embedding function
  * Uses UniversalSentenceEncoder for all text embeddings
  * TensorFlow.js is required for this to work
+ * Uses threading when available for better performance
  */
-const defaultEmbeddingFunction = createTensorFlowEmbeddingFunction();
+const defaultEmbeddingFunction = createThreadedEmbeddingFunction({ fallbackToMain: true });
 
 /**
  * HNSW (Hierarchical Navigable Small World) Index implementation
@@ -2706,18 +2954,73 @@ const DEFAULT_CONFIG = {
     ml: 16 // Max level
 };
 class HNSWIndex {
-    constructor(config = {}, distanceFunction = euclideanDistance) {
+    constructor(config = {}, distanceFunction = euclideanDistance, options = {}) {
         this.nouns = new Map();
         this.entryPointId = null;
         this.maxLevel = 0;
         this.dimension = null;
+        this.useParallelization = true; // Whether to use parallelization for performance-critical operations
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.distanceFunction = distanceFunction;
+        this.useParallelization = options.useParallelization !== undefined ? options.useParallelization : true;
+    }
+    /**
+     * Set whether to use parallelization for performance-critical operations
+     */
+    setUseParallelization(useParallelization) {
+        this.useParallelization = useParallelization;
+    }
+    /**
+     * Get whether parallelization is enabled
+     */
+    getUseParallelization() {
+        return this.useParallelization;
+    }
+    /**
+     * Calculate distances between a query vector and multiple vectors in parallel
+     * This is used to optimize performance for search operations
+     * @param queryVector The query vector
+     * @param vectors Array of vectors to compare against
+     * @returns Array of distances
+     */
+    async calculateDistancesInParallel(queryVector, vectors) {
+        // If parallelization is disabled or there are very few vectors, use sequential processing
+        if (!this.useParallelization || vectors.length < 10) {
+            return vectors.map(item => ({
+                id: item.id,
+                distance: this.distanceFunction(queryVector, item.vector)
+            }));
+        }
+        // Function to be executed in a worker thread
+        const distanceCalculator = (args) => {
+            const { queryVector, vectors, distanceFnString } = args;
+            // Recreate the distance function from its string representation
+            const distanceFunction = new Function('return ' + distanceFnString)();
+            // Calculate distances for all items
+            return vectors.map(item => ({
+                id: item.id,
+                distance: distanceFunction(queryVector, item.vector)
+            }));
+        };
+        try {
+            // Convert the distance function to a string for serialization
+            const distanceFnString = this.distanceFunction.toString();
+            // Execute the distance calculation in a separate thread
+            return await executeInThread(distanceCalculator.toString(), { queryVector, vectors, distanceFnString });
+        }
+        catch (error) {
+            console.error('Error in parallel distance calculation, falling back to sequential:', error);
+            // Fall back to sequential processing if parallel execution fails
+            return vectors.map(item => ({
+                id: item.id,
+                distance: this.distanceFunction(queryVector, item.vector)
+            }));
+        }
     }
     /**
      * Add a vector to the index
      */
-    addItem(item) {
+    async addItem(item) {
         // Check if item is defined
         if (!item) {
             throw new Error('Item is undefined or null');
@@ -2799,7 +3102,7 @@ class HNSWIndex {
         // For each level from nounLevel down to 0
         for (let level = Math.min(nounLevel, this.maxLevel); level >= 0; level--) {
             // Find ef nearest elements using greedy search
-            const nearestNouns = this.searchLayer(vector, currObj, this.config.efConstruction, level);
+            const nearestNouns = await this.searchLayer(vector, currObj, this.config.efConstruction, level);
             // Select M nearest neighbors
             const neighbors = this.selectNeighbors(vector, nearestNouns, this.config.M);
             // Add bidirectional connections
@@ -2848,7 +3151,7 @@ class HNSWIndex {
     /**
      * Search for nearest neighbors
      */
-    search(queryVector, k = 10) {
+    async search(queryVector, k = 10) {
         if (this.nouns.size === 0) {
             return [];
         }
@@ -2878,23 +3181,50 @@ class HNSWIndex {
                 changed = false;
                 // Check all neighbors at current level
                 const connections = currObj.connections.get(level) || new Set();
-                for (const neighborId of connections) {
-                    const neighbor = this.nouns.get(neighborId);
-                    if (!neighbor) {
-                        // Skip neighbors that don't exist (expected during rapid additions/deletions)
-                        continue;
+                // If we have enough connections, use parallel distance calculation
+                if (this.useParallelization && connections.size >= 10) {
+                    // Prepare vectors for parallel calculation
+                    const vectors = [];
+                    for (const neighborId of connections) {
+                        const neighbor = this.nouns.get(neighborId);
+                        if (!neighbor)
+                            continue;
+                        vectors.push({ id: neighborId, vector: neighbor.vector });
                     }
-                    const distToNeighbor = this.distanceFunction(queryVector, neighbor.vector);
-                    if (distToNeighbor < currDist) {
-                        currDist = distToNeighbor;
-                        currObj = neighbor;
-                        changed = true;
+                    // Calculate distances in parallel
+                    const distances = await this.calculateDistancesInParallel(queryVector, vectors);
+                    // Find the closest neighbor
+                    for (const { id, distance } of distances) {
+                        if (distance < currDist) {
+                            currDist = distance;
+                            const neighbor = this.nouns.get(id);
+                            if (neighbor) {
+                                currObj = neighbor;
+                                changed = true;
+                            }
+                        }
+                    }
+                }
+                else {
+                    // Use sequential processing for small number of connections
+                    for (const neighborId of connections) {
+                        const neighbor = this.nouns.get(neighborId);
+                        if (!neighbor) {
+                            // Skip neighbors that don't exist (expected during rapid additions/deletions)
+                            continue;
+                        }
+                        const distToNeighbor = this.distanceFunction(queryVector, neighbor.vector);
+                        if (distToNeighbor < currDist) {
+                            currDist = distToNeighbor;
+                            currObj = neighbor;
+                            changed = true;
+                        }
                     }
                 }
             }
         }
         // Search at level 0 with ef = k
-        const nearestNouns = this.searchLayer(queryVector, currObj, Math.max(this.config.efSearch, k), 0);
+        const nearestNouns = await this.searchLayer(queryVector, currObj, Math.max(this.config.efSearch, k), 0);
         // Convert to array and sort by distance
         return [...nearestNouns].slice(0, k);
     }
@@ -3014,7 +3344,7 @@ class HNSWIndex {
      * Search within a specific layer
      * Returns a map of noun IDs to distances, sorted by distance
      */
-    searchLayer(queryVector, entryPoint, ef, level) {
+    async searchLayer(queryVector, entryPoint, ef, level) {
         // Set of visited nouns
         const visited = new Set([entryPoint.id]);
         // Priority queue of candidates (closest first)
@@ -3040,25 +3370,62 @@ class HNSWIndex {
                 continue;
             }
             const connections = noun.connections.get(level) || new Set();
-            for (const neighborId of connections) {
-                if (!visited.has(neighborId)) {
-                    visited.add(neighborId);
-                    const neighbor = this.nouns.get(neighborId);
-                    if (!neighbor) {
-                        // Skip neighbors that don't exist (expected during rapid additions/deletions)
-                        continue;
+            // If we have enough connections and parallelization is enabled, use parallel distance calculation
+            if (this.useParallelization && connections.size >= 10) {
+                // Collect unvisited neighbors
+                const unvisitedNeighbors = [];
+                for (const neighborId of connections) {
+                    if (!visited.has(neighborId)) {
+                        visited.add(neighborId);
+                        const neighbor = this.nouns.get(neighborId);
+                        if (!neighbor)
+                            continue;
+                        unvisitedNeighbors.push({ id: neighborId, vector: neighbor.vector });
                     }
-                    const distToNeighbor = this.distanceFunction(queryVector, neighbor.vector);
-                    // If we haven't found ef nearest neighbors yet, or this neighbor is closer than the farthest one we've found
-                    if (nearest.size < ef || distToNeighbor < farthestInNearest[1]) {
-                        candidates.set(neighborId, distToNeighbor);
-                        nearest.set(neighborId, distToNeighbor);
-                        // If we have more than ef neighbors, remove the farthest one
-                        if (nearest.size > ef) {
-                            const sortedNearest = [...nearest].sort((a, b) => a[1] - b[1]);
-                            nearest.clear();
-                            for (let i = 0; i < ef; i++) {
-                                nearest.set(sortedNearest[i][0], sortedNearest[i][1]);
+                }
+                if (unvisitedNeighbors.length > 0) {
+                    // Calculate distances in parallel
+                    const distances = await this.calculateDistancesInParallel(queryVector, unvisitedNeighbors);
+                    // Process the results
+                    for (const { id, distance } of distances) {
+                        // If we haven't found ef nearest neighbors yet, or this neighbor is closer than the farthest one we've found
+                        if (nearest.size < ef || distance < farthestInNearest[1]) {
+                            candidates.set(id, distance);
+                            nearest.set(id, distance);
+                            // If we have more than ef neighbors, remove the farthest one
+                            if (nearest.size > ef) {
+                                const sortedNearest = [...nearest].sort((a, b) => a[1] - b[1]);
+                                nearest.clear();
+                                for (let i = 0; i < ef; i++) {
+                                    nearest.set(sortedNearest[i][0], sortedNearest[i][1]);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // Use sequential processing for small number of connections
+                for (const neighborId of connections) {
+                    if (!visited.has(neighborId)) {
+                        visited.add(neighborId);
+                        const neighbor = this.nouns.get(neighborId);
+                        if (!neighbor) {
+                            // Skip neighbors that don't exist (expected during rapid additions/deletions)
+                            continue;
+                        }
+                        const distToNeighbor = this.distanceFunction(queryVector, neighbor.vector);
+                        // If we haven't found ef nearest neighbors yet, or this neighbor is closer than the farthest one we've found
+                        if (nearest.size < ef || distToNeighbor < farthestInNearest[1]) {
+                            candidates.set(neighborId, distToNeighbor);
+                            nearest.set(neighborId, distToNeighbor);
+                            // If we have more than ef neighbors, remove the farthest one
+                            if (nearest.size > ef) {
+                                const sortedNearest = [...nearest].sort((a, b) => a[1] - b[1]);
+                                nearest.clear();
+                                for (let i = 0; i < ef; i++) {
+                                    nearest.set(sortedNearest[i][0], sortedNearest[i][1]);
+                                }
                             }
                         }
                     }
@@ -3361,7 +3728,7 @@ class HNSWIndexOptimized extends HNSWIndex {
      * Add a vector to the index
      * Uses product quantization if enabled and memory threshold is exceeded
      */
-    addItem(item) {
+    async addItem(item) {
         // Check if item is defined
         if (!item) {
             throw new Error('Item is undefined or null');
@@ -3397,7 +3764,7 @@ class HNSWIndexOptimized extends HNSWIndex {
             // Reconstruct the vector for indexing
             const reconstructedVector = this.productQuantizer.reconstruct(codes);
             // Add the reconstructed vector to the index
-            return super.addItem({ id, vector: reconstructedVector });
+            return await super.addItem({ id, vector: reconstructedVector });
         }
         // If disk-based index is active and storage is available, store the vector
         if (this.useDiskBasedIndex && this.storage) {
@@ -3413,13 +3780,13 @@ class HNSWIndexOptimized extends HNSWIndex {
             });
         }
         // Add the vector to the in-memory index
-        return super.addItem(item);
+        return await super.addItem(item);
     }
     /**
      * Search for nearest neighbors
      * Uses product quantization if enabled
      */
-    search(queryVector, k = 10) {
+    async search(queryVector, k = 10) {
         // Check if query vector is defined
         if (!queryVector) {
             throw new Error('Query vector is undefined or null');
@@ -3433,10 +3800,10 @@ class HNSWIndexOptimized extends HNSWIndex {
             // Reconstruct the query vector
             const reconstructedVector = this.productQuantizer.reconstruct(codes);
             // Search with the reconstructed vector
-            return super.search(reconstructedVector, k);
+            return await super.search(reconstructedVector, k);
         }
         // Otherwise, use the standard search
-        return super.search(queryVector, k);
+        return await super.search(queryVector, k);
     }
     /**
      * Remove an item from the index
@@ -7001,7 +7368,7 @@ class BrainyData {
             this.index.clear();
             for (const noun of nouns) {
                 // Add to index
-                this.index.addItem({
+                await this.index.addItem({
                     id: noun.id,
                     vector: noun.vector
                 });
@@ -7087,7 +7454,7 @@ class BrainyData {
                     ? metadata.id
                     : v4());
             // Add to index
-            this.index.addItem({ id, vector });
+            await this.index.addItem({ id, vector });
             // Get the noun from the index
             const noun = this.index.getNouns().get(id);
             if (!noun) {
@@ -7178,11 +7545,19 @@ class BrainyData {
         await this.ensureInitialized();
         // Check if database is in read-only mode
         this.checkReadOnly();
-        const ids = [];
+        // Default concurrency to 4 if not specified
+        const concurrency = options.concurrency || 4;
         try {
-            for (const item of items) {
-                const id = await this.add(item.vectorOrData, item.metadata, options);
-                ids.push(id);
+            // Process items in batches to control concurrency
+            const ids = [];
+            const itemsToProcess = [...items]; // Create a copy to avoid modifying the original array
+            while (itemsToProcess.length > 0) {
+                // Take up to 'concurrency' items to process in parallel
+                const batch = itemsToProcess.splice(0, concurrency);
+                // Process this batch in parallel
+                const batchResults = await Promise.all(batch.map(item => this.add(item.vectorOrData, item.metadata, options)));
+                // Add the results to our ids array
+                ids.push(...batchResults);
             }
             return ids;
         }
@@ -7240,7 +7615,7 @@ class BrainyData {
             // If no noun types specified, search all nouns
             if (!nounTypes || nounTypes.length === 0) {
                 // Search in the index
-                const results = this.index.search(queryVector, k);
+                const results = await this.index.search(queryVector, k);
                 // Get metadata for each result
                 const searchResults = [];
                 for (const [id, score] of results) {
@@ -7633,7 +8008,7 @@ class BrainyData {
                 metadata: options.metadata
             };
             // Add to index
-            this.index.addItem({ id, vector: verbVector });
+            await this.index.addItem({ id, vector: verbVector });
             // Get the noun from the index
             const indexNoun = this.index.getNouns().get(id);
             if (!indexNoun) {
@@ -8373,7 +8748,7 @@ class BrainyData {
                     // Re-add all nouns to the index
                     for (const noun of data.nouns) {
                         if (noun.vector && noun.vector.length > 0) {
-                            this.index.addItem({ id: noun.id, vector: noun.vector });
+                            await this.index.addItem({ id: noun.id, vector: noun.vector });
                         }
                     }
                     console.log('HNSW index reconstruction complete');
@@ -10230,177 +10605,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;
-}
-/**
- * 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
- */
-function isThreadingAvailable() {
-    return areWebWorkersAvailable() || areWorkerThreadsAvailable();
-}
-
-/**
- * Utility functions for working with Web Workers and Worker Threads
- */
-/**
- * Execute a function in a Web Worker (browser environment)
- *
- * @param fn The function to execute
- * @param args The arguments to pass to the function
- * @returns A promise that resolves with the result of the function
- */
-function executeInWebWorker(fn, ...args) {
-    return new Promise((resolve, reject) => {
-        // Create a blob URL for the worker script
-        const fnString = fn.toString();
-        const workerScript = `
-      self.onmessage = function(e) {
-        try {
-          const fn = ${fnString};
-          const result = fn(...e.data);
-          self.postMessage({ success: true, data: result });
-        } catch (error) {
-          self.postMessage({ 
-            success: false, 
-            error: error instanceof Error ? error.message : String(error) 
-          });
-        }
-      };
-    `;
-        const blob = new Blob([workerScript], { type: 'application/javascript' });
-        const blobURL = URL.createObjectURL(blob);
-        // Create a worker
-        const worker = new Worker(blobURL);
-        // Set up message handling
-        worker.onmessage = function (e) {
-            URL.revokeObjectURL(blobURL); // Clean up
-            worker.terminate(); // Terminate the worker
-            if (e.data.success) {
-                resolve(e.data.data);
-            }
-            else {
-                reject(new Error(e.data.error));
-            }
-        };
-        worker.onerror = function (error) {
-            URL.revokeObjectURL(blobURL); // Clean up
-            worker.terminate(); // Terminate the worker
-            reject(error);
-        };
-        // Start the worker
-        worker.postMessage(args);
-    });
-}
-/**
- * Execute a function in a Worker Thread (Node.js environment)
- *
- * @param fn The function to execute
- * @param args The arguments to pass to the function
- * @returns A promise that resolves with the result of the function
- */
-function executeInWorkerThread(fn, ...args) {
-    return new Promise((resolve, reject) => {
-        try {
-            // Dynamic import to avoid errors in browser environments
-            const { Worker } = require('worker_threads');
-            // Create a worker script
-            const fnString = fn.toString();
-            const workerScript = `
-        const { parentPort } = require('worker_threads');
-
-        parentPort.once('message', (data) => {
-          try {
-            const fn = ${fnString};
-            const result = fn(...data);
-            parentPort.postMessage({ success: true, data: result });
-          } catch (error) {
-            parentPort.postMessage({ 
-              success: false, 
-              error: error instanceof Error ? error.message : String(error) 
-            });
-          }
-        });
-      `;
-            // Create a worker
-            const worker = new Worker(workerScript, { eval: true });
-            // Set up message handling
-            worker.on('message', (data) => {
-                worker.terminate(); // Terminate the worker
-                if (data.success) {
-                    resolve(data.data);
-                }
-                else {
-                    reject(new Error(data.error));
-                }
-            });
-            worker.on('error', (error) => {
-                worker.terminate(); // Terminate the worker
-                reject(error);
-            });
-            // Start the worker
-            worker.postMessage(args);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-}
-/**
- * Execute a function in a separate thread based on the environment
- *
- * @param fn The function to execute
- * @param args The arguments to pass to the function
- * @returns A promise that resolves with the result of the function
- */
-function executeInThread(fn, ...args) {
-    if (isBrowser$1()) {
-        return executeInWebWorker(fn, ...args);
-    }
-    else if (isNode()) {
-        return executeInWorkerThread(fn, ...args);
-    }
-    else {
-        // Fall back to executing in the main thread
-        return Promise.resolve(fn(...args));
-    }
-}
-
 /**
  * Augmentation Registry
  *
@@ -10996,7 +11200,7 @@ class Pipeline {
                                 const augFn = augmentation[method];
                                 return augFn.apply(augmentation, workerArgs);
                             };
-                            methodPromise = executeInThread(workerFn, ...args);
+                            methodPromise = executeInThread(workerFn.toString(), args);
                         }
                         catch (threadError) {
                             console.warn(`Failed to execute in thread, falling back to main thread: ${threadError}`);
@@ -11658,7 +11862,7 @@ class AugmentationPipeline {
                             const augFn = augmentation[method];
                             return augFn.apply(augmentation, workerArgs);
                         };
-                        methodPromise = executeInThread(workerFn, ...args);
+                        methodPromise = executeInThread(workerFn.toString(), args);
                     }
                     catch (threadError) {
                         console.warn(`Failed to execute in thread, falling back to main thread: ${threadError}`);
@@ -116925,5 +117129,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, 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, 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 };
 //# sourceMappingURL=brainy.js.map