chore: recovery checkpoint - v3.0 API successfully recovered
CRITICAL CHECKPOINT - DO NOT PUSH TO GITHUB Recovery Status: - Successfully recovered brainy.ts from compiled JavaScript - All core v3.0 API methods functional (add, get, update, delete, relate, find, etc.) - Neural subsystem intact (562KB embedded patterns, NLP working) - Augmentation pipeline operational (20+ augmentations) - HNSW clustering system complete - Triple Intelligence compiled (needs constructor fix) - Test suite validates functionality Changes preserved: - 898 files with changes from last 3 days - 144,475 insertions - All augmentation improvements - All test coverage enhancements - Complete v3.0 feature set This is a LOCAL checkpoint only - contains recovered work after corruption incident. Created backup in .backups/brainy-full-20250910-151314.tar.gz Branch: recovery-checkpoint-20250910-151433 Date: Wed Sep 10 03:18:04 PM PDT 2025
This commit is contained in:
parent
f65455fb22
commit
8ff382ca3b
895 changed files with 143654 additions and 28268 deletions
|
|
@ -0,0 +1,458 @@
|
|||
/**
|
||||
* 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
|
||||
Loading…
Add table
Add a link
Reference in a new issue