David Snelling
f8c45f2d8d
Open source vector database with HNSW indexing, graph relationships, and metadata facets. Features CLI with professional augmentation registry integration for discovering extensions and capabilities.
458 lines
No EOL
19 KiB
JavaScript
458 lines
No EOL
19 KiB
JavaScript
/**
|
|
* 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
|
|
*/
|
|
import { isBrowser, isNode } from './environment.js';
|
|
// Worker pool to reuse workers
|
|
const workerPool = new Map();
|
|
const MAX_POOL_SIZE = 4; // Adjust based on system capabilities
|
|
/**
|
|
* 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
|
|
*/
|
|
export function executeInThread(fnString, args) {
|
|
if (isNode()) {
|
|
return executeInNodeWorker(fnString, args);
|
|
}
|
|
else if (isBrowser() && typeof window !== 'undefined' && window.Worker) {
|
|
return executeInWebWorker(fnString, args);
|
|
}
|
|
else {
|
|
// Fallback to main thread execution
|
|
try {
|
|
// 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.warn('Fallback: Direct approach failed, trying with function wrapper', directError);
|
|
try {
|
|
// Try wrapping in a function that returns the function expression
|
|
fn = new Function('return function(args) { return (' + fnString + ')(args); }')();
|
|
}
|
|
catch (wrapperError) {
|
|
console.error('Fallback: All approaches to create function failed', wrapperError);
|
|
throw new Error('Failed to create function from string: ' +
|
|
functionError.message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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';
|
|
|
|
// Add TensorFlow.js platform patch for Node.js
|
|
if (typeof global !== 'undefined') {
|
|
try {
|
|
// Define a custom PlatformNode class
|
|
class PlatformNode {
|
|
constructor() {
|
|
// Create a util object with necessary methods
|
|
this.util = {
|
|
// Add isFloat32Array and isTypedArray directly to util
|
|
isFloat32Array: (arr) => {
|
|
return !!(
|
|
arr instanceof Float32Array ||
|
|
(arr &&
|
|
Object.prototype.toString.call(arr) === '[object Float32Array]')
|
|
);
|
|
},
|
|
isTypedArray: (arr) => {
|
|
return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
|
|
},
|
|
// Use native TextEncoder and TextDecoder
|
|
TextEncoder: TextEncoder,
|
|
TextDecoder: TextDecoder
|
|
};
|
|
|
|
// Initialize encoders using native constructors
|
|
this.textEncoder = new TextEncoder();
|
|
this.textDecoder = new TextDecoder();
|
|
}
|
|
|
|
// Define isFloat32Array directly on the instance
|
|
isFloat32Array(arr) {
|
|
return !!(
|
|
arr instanceof Float32Array ||
|
|
(arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
|
|
);
|
|
}
|
|
|
|
// Define isTypedArray directly on the instance
|
|
isTypedArray(arr) {
|
|
return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
|
|
}
|
|
}
|
|
|
|
// Assign the PlatformNode class to the global object
|
|
global.PlatformNode = PlatformNode;
|
|
|
|
// Also create an instance and assign it to global.platformNode
|
|
global.platformNode = new PlatformNode();
|
|
|
|
// Ensure global.util exists and has the necessary methods
|
|
if (!global.util) {
|
|
global.util = {};
|
|
}
|
|
|
|
// Add isFloat32Array method if it doesn't exist
|
|
if (!global.util.isFloat32Array) {
|
|
global.util.isFloat32Array = (arr) => {
|
|
return !!(
|
|
arr instanceof Float32Array ||
|
|
(arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
|
|
);
|
|
};
|
|
}
|
|
|
|
// Add isTypedArray method if it doesn't exist
|
|
if (!global.util.isTypedArray) {
|
|
global.util.isTypedArray = (arr) => {
|
|
return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.warn('Failed to apply TensorFlow.js platform patch:', error);
|
|
}
|
|
}
|
|
|
|
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';
|
|
|
|
// Add TensorFlow.js platform patch for Node.js
|
|
if (typeof global !== 'undefined') {
|
|
try {
|
|
// Define a custom PlatformNode class
|
|
class PlatformNode {
|
|
constructor() {
|
|
// Create a util object with necessary methods
|
|
this.util = {
|
|
// Use native TextEncoder and TextDecoder
|
|
TextEncoder: TextEncoder,
|
|
TextDecoder: TextDecoder
|
|
};
|
|
|
|
// Initialize encoders using native constructors
|
|
this.textEncoder = new TextEncoder();
|
|
this.textDecoder = new TextDecoder();
|
|
}
|
|
|
|
// Define isFloat32Array directly on the instance
|
|
isFloat32Array(arr) {
|
|
return !!(
|
|
arr instanceof Float32Array ||
|
|
(arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
|
|
);
|
|
}
|
|
|
|
// Define isTypedArray directly on the instance
|
|
isTypedArray(arr) {
|
|
return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
|
|
}
|
|
}
|
|
|
|
// Assign the PlatformNode class to the global object
|
|
global.PlatformNode = PlatformNode;
|
|
|
|
// Also create an instance and assign it to global.platformNode
|
|
global.platformNode = new PlatformNode();
|
|
|
|
// Ensure global.util exists and has the necessary methods
|
|
if (!global.util) {
|
|
global.util = {};
|
|
}
|
|
|
|
// Add isFloat32Array method if it doesn't exist
|
|
if (!global.util.isFloat32Array) {
|
|
global.util.isFloat32Array = (arr) => {
|
|
return !!(
|
|
arr instanceof Float32Array ||
|
|
(arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
|
|
);
|
|
};
|
|
}
|
|
|
|
// Add isTypedArray method if it doesn't exist
|
|
if (!global.util.isTypedArray) {
|
|
global.util.isTypedArray = (arr) => {
|
|
return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.warn('Failed to apply TensorFlow.js platform patch:', error);
|
|
}
|
|
}
|
|
|
|
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 {
|
|
// 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));
|
|
}
|
|
else {
|
|
resolve(e.data.result);
|
|
}
|
|
worker.terminate();
|
|
};
|
|
worker.onerror = function (e) {
|
|
clearTimeout(timeoutId);
|
|
console.warn('Web Worker error, falling back to main thread execution:', e.message);
|
|
worker.terminate();
|
|
// Execute in main thread as fallback
|
|
try {
|
|
const fn = new Function('return ' + fnString)();
|
|
resolve(fn(args));
|
|
}
|
|
catch (mainThreadError) {
|
|
reject(mainThreadError);
|
|
}
|
|
};
|
|
worker.postMessage({ fnString, args });
|
|
}
|
|
catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Clean up all worker pools
|
|
* This should be called when the application is shutting down
|
|
*/
|
|
export function cleanupWorkerPools() {
|
|
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);
|
|
}
|
|
}
|
|
//# sourceMappingURL=workerUtils.js.map
|