@soulcraft/brainy 0.10.0 → 0.12.0

package/dist/unified.js

@@ -2395,135 +2395,400 @@ 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.
+ * Utility functions for environment detection
  */
 /**
- * A simple text encoder that works in all environments
- * This avoids the need for TextEncoder polyfills and patches
+ * Check if code is running in a browser environment
  */
-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)));
-    }
+function isBrowser$1() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 /**
- * A simple text decoder that works in all environments
- * This avoids the need for TextDecoder polyfills and patches
+ * Check if code is running in a Node.js environment
  */
-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]);
+function isNode() {
+    // If browser environment is detected, prioritize it over Node.js
+    // This handles cases like jsdom where both window and process exist
+    if (isBrowser$1()) {
+        return false;
     }
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
 }
 /**
- * A constructor function for TextEncoder that works in all environments
+ * Check if code is running in a Web Worker environment
  */
-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);
-    }
+function isWebWorker() {
+    return (typeof self === 'object' &&
+        self.constructor &&
+        self.constructor.name === 'DedicatedWorkerGlobalScope');
 }
 /**
- * A constructor function for TextDecoder that works in all environments
+ * Check if Web Workers are available in the current environment
  */
-function UniversalTextDecoder() {
-    if (!(this instanceof UniversalTextDecoder)) {
-        return new UniversalTextDecoder();
-    }
+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 {
-        // Try to use the native TextDecoder if available
-        const nativeDecoder = new TextDecoder();
-        this.decode = nativeDecoder.decode.bind(nativeDecoder);
+        // Use dynamic import to avoid errors in browser environments
+        await import('worker_threads');
+        return true;
     }
     catch (e) {
-        // Fall back to our simple implementation
-        const simpleDecoder = new SimpleTextDecoder();
-        this.decode = simpleDecoder.decode.bind(simpleDecoder);
+        return false;
     }
 }
 /**
- * Get a text encoder that works in the current environment
- * @returns A text encoder object with an encode method
+ * Synchronous version that doesn't actually try to load the module
+ * This is safer in ES module environments
  */
-function getTextEncoder() {
-    return new UniversalTextEncoder();
+function areWorkerThreadsAvailableSync() {
+    if (!isNode())
+        return false;
+    // In Node.js 24.4.0+, worker_threads is always available
+    return parseInt(process.versions.node.split('.')[0]) >= 24;
 }
 /**
- * Get a text decoder that works in the current environment
- * @returns A text decoder object with a decode method
+ * Determine if threading is available in the current environment
+ * Returns true if either Web Workers (browser) or Worker Threads (Node.js) are available
  */
-function getTextDecoder() {
-    return new UniversalTextDecoder();
+function isThreadingAvailable() {
+    return areWebWorkersAvailable() || areWorkerThreadsAvailableSync();
 }
 /**
- * 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
+ * Async version of isThreadingAvailable
+ */
+async function isThreadingAvailableAsync() {
+    return areWebWorkersAvailable() || (await areWorkerThreadsAvailable());
+}
+
+/**
+ * Flag to track if the patch has been applied
  */
-function applyTensorFlowPatch() {
-    // Only apply in Node.js environment
-    if (typeof global !== 'undefined' &&
-        typeof process !== 'undefined' &&
-        process.versions &&
-        process.versions.node) {
+let patchApplied = false;
+/**
+ * Monkeypatch TensorFlow.js's PlatformNode class to fix TextEncoder/TextDecoder issues
+ * CRITICAL: This runs immediately at the top level when this module is imported
+ */
+if (typeof globalThis !== 'undefined' && isNode()) {
+    try {
+        // Ensure TextEncoder/TextDecoder are globally available
+        if (typeof globalThis.TextEncoder === 'undefined') {
+            globalThis.TextEncoder = TextEncoder;
+        }
+        if (typeof globalThis.TextDecoder === 'undefined') {
+            globalThis.TextDecoder = TextDecoder;
+        }
+        // Patch global objects to handle the TensorFlow.js constructor issue
+        // This is needed because TF accesses TextEncoder/TextDecoder as constructors via this.util
+        if (typeof global !== 'undefined') {
+            if (!global.TextEncoder) {
+                global.TextEncoder = TextEncoder;
+            }
+            if (!global.TextDecoder) {
+                global.TextDecoder = TextDecoder;
+            }
+            // Also set the special global constructors that TensorFlow can use safely
+            global.__TextEncoder__ = TextEncoder;
+            global.__TextDecoder__ = TextDecoder;
+        }
+        // CRITICAL FIX: Create a custom util object that TensorFlow.js can use
+        // We'll make this available globally so TensorFlow.js can find it
+        const customUtil = {
+            TextEncoder: TextEncoder,
+            TextDecoder: TextDecoder,
+            types: {
+                isFloat32Array: (arr) => arr instanceof Float32Array,
+                isInt32Array: (arr) => arr instanceof Int32Array,
+                isUint8Array: (arr) => arr instanceof Uint8Array,
+                isUint8ClampedArray: (arr) => arr instanceof Uint8ClampedArray
+            }
+        };
+        // Make the custom util available globally
+        if (typeof global !== 'undefined') {
+            global.__brainy_util__ = customUtil;
+        }
+        // Try to patch the global require cache if possible
+        if (typeof global !== 'undefined' &&
+            global.require &&
+            global.require.cache) {
+            // Find the util module in the cache and patch it
+            for (const key in global.require.cache) {
+                if (key.endsWith('/util.js') || key === 'util') {
+                    const utilModule = global.require.cache[key];
+                    if (utilModule && utilModule.exports) {
+                        Object.assign(utilModule.exports, customUtil);
+                    }
+                }
+            }
+        }
+        // CRITICAL: Patch the Node.js util module directly
         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
+            const util = require('util');
+            // Ensure TextEncoder and TextDecoder are available as constructors
+            util.TextEncoder = TextEncoder;
+            util.TextDecoder = TextDecoder;
+        }
+        catch (error) {
+            // Ignore if util module is not available
+        }
+        // CRITICAL: Patch Float32Array to handle buffer alignment issues
+        // This fixes the "byte length of Float32Array should be a multiple of 4" error
+        if (typeof global !== 'undefined') {
+            const originalFloat32Array = global.Float32Array;
+            global.Float32Array = class extends originalFloat32Array {
+                constructor(arg, byteOffset, length) {
+                    if (arg instanceof ArrayBuffer) {
+                        // Ensure buffer is properly aligned for Float32Array (multiple of 4 bytes)
+                        const alignedByteOffset = byteOffset || 0;
+                        const alignedLength = length !== undefined
+                            ? length
+                            : (arg.byteLength - alignedByteOffset) / 4;
+                        // Check if the buffer slice is properly aligned
+                        if ((arg.byteLength - alignedByteOffset) % 4 !== 0 &&
+                            length === undefined) {
+                            // Create a new aligned buffer if the original isn't properly aligned
+                            const alignedByteLength = Math.floor((arg.byteLength - alignedByteOffset) / 4) * 4;
+                            const alignedBuffer = new ArrayBuffer(alignedByteLength);
+                            const sourceView = new Uint8Array(arg, alignedByteOffset, alignedByteLength);
+                            const targetView = new Uint8Array(alignedBuffer);
+                            targetView.set(sourceView);
+                            super(alignedBuffer);
+                        }
+                        else {
+                            super(arg, alignedByteOffset, alignedLength);
+                        }
+                    }
+                    else {
+                        super(arg, byteOffset, length);
+                    }
+                }
+            };
+            // Preserve static methods and properties
+            Object.setPrototypeOf(global.Float32Array, originalFloat32Array);
+            Object.defineProperty(global.Float32Array, 'name', {
+                value: 'Float32Array'
+            });
+            Object.defineProperty(global.Float32Array, 'BYTES_PER_ELEMENT', {
+                value: 4
+            });
+        }
+        // CRITICAL: Patch any empty util shims that bundlers might create
+        // This handles cases where bundlers provide empty shims for Node.js modules
+        if (typeof global !== 'undefined') {
+            // Look for common patterns of util shims in bundled code
+            const checkAndPatchUtilShim = (obj) => {
+                if (obj && typeof obj === 'object' && !obj.TextEncoder) {
+                    obj.TextEncoder = TextEncoder;
+                    obj.TextDecoder = TextDecoder;
+                    obj.types = obj.types || {
+                        isFloat32Array: (arr) => arr instanceof Float32Array,
+                        isInt32Array: (arr) => arr instanceof Int32Array,
+                        isUint8Array: (arr) => arr instanceof Uint8Array,
+                        isUint8ClampedArray: (arr) => arr instanceof Uint8ClampedArray
                     };
-                    // Initialize using the constructors from util
-                    this.textEncoder = new TextEncoder();
-                    this.textDecoder = new TextDecoder();
                 }
+            };
+            // Patch any existing util-like objects in global scope
+            if (global._utilShim) {
+                checkAndPatchUtilShim(global._utilShim);
+            }
+            // CRITICAL: Patch the bundled util shim directly
+            // In bundled code, there's often a _utilShim object that needs patching
+            if (typeof globalThis !== 'undefined' &&
+                globalThis._utilShim) {
+                checkAndPatchUtilShim(globalThis._utilShim);
+            }
+            // CRITICAL: Create and patch a global _utilShim if it doesn't exist
+            // This ensures the bundled code will find the patched version
+            if (!global._utilShim) {
+                global._utilShim = {
+                    TextEncoder: TextEncoder,
+                    TextDecoder: TextDecoder,
+                    types: {
+                        isFloat32Array: (arr) => arr instanceof Float32Array,
+                        isInt32Array: (arr) => arr instanceof Int32Array,
+                        isUint8Array: (arr) => arr instanceof Uint8Array,
+                        isUint8ClampedArray: (arr) => arr instanceof Uint8ClampedArray
+                    }
+                };
+            }
+            else {
+                checkAndPatchUtilShim(global._utilShim);
+            }
+            // Also ensure it's available on globalThis
+            if (typeof globalThis !== 'undefined' &&
+                !globalThis._utilShim) {
+                ;
+                globalThis._utilShim = global._utilShim;
+            }
+            // Set up a property descriptor to catch util shim assignments
+            try {
+                Object.defineProperty(global, '_utilShim', {
+                    get() {
+                        return this.__utilShim || {};
+                    },
+                    set(value) {
+                        checkAndPatchUtilShim(value);
+                        this.__utilShim = value;
+                    },
+                    configurable: true
+                });
+            }
+            catch (e) {
+                // Ignore if property can't be defined
+            }
+            // Also set up property descriptor on globalThis
+            try {
+                Object.defineProperty(globalThis, '_utilShim', {
+                    get() {
+                        return this.__utilShim || {};
+                    },
+                    set(value) {
+                        checkAndPatchUtilShim(value);
+                        this.__utilShim = value;
+                    },
+                    configurable: true
+                });
+            }
+            catch (e) {
+                // Ignore if property can't be defined
             }
-            // Assign the PlatformNode class to the global object
-            ;
-            global.PlatformNode = PlatformNode;
-            global.platformNode = new PlatformNode();
+        }
+        console.log('Brainy: Successfully patched TensorFlow.js PlatformNode at module load time');
+        patchApplied = true;
+    }
+    catch (error) {
+        console.warn('Brainy: Failed to apply early TensorFlow.js platform patch:', error);
+    }
+}
+/**
+ * Apply the TensorFlow.js platform patch if it hasn't been applied already
+ * This is a safety measure in case the module-level patch didn't run
+ * Now works across all environments: browser, Node.js, and serverless/server
+ */
+async function applyTensorFlowPatch() {
+    // Apply patches for all non-browser environments that might need TensorFlow.js compatibility
+    // This includes Node.js, serverless environments, and other server environments
+    const isBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
+    if (isBrowserEnv) {
+        return; // Browser environments don't need these patches
+    }
+    // Get the appropriate global object for the current environment
+    const globalObj = (() => {
+        if (typeof globalThis !== 'undefined')
+            return globalThis;
+        if (typeof global !== 'undefined')
+            return global;
+        if (typeof self !== 'undefined')
+            return self;
+        return {}; // Fallback for unknown environments
+    })();
+    // Check if the critical globals exist, not just the flag
+    // This allows re-patching if globals have been deleted
+    const needsPatch = !patchApplied ||
+        typeof globalObj.__TextEncoder__ === 'undefined' ||
+        typeof globalObj.__TextDecoder__ === 'undefined';
+    if (!needsPatch) {
+        return;
+    }
+    try {
+        console.log('Brainy: Applying TensorFlow.js platform patch via function call');
+        // CRITICAL FIX: Patch the global environment to ensure TextEncoder/TextDecoder are available
+        // This approach works by ensuring the global constructors are available before TensorFlow.js loads
+        // Now works across all environments: Node.js, serverless, and other server environments
+        // Make sure TextEncoder and TextDecoder are available globally
+        if (!globalObj.TextEncoder) {
+            globalObj.TextEncoder = TextEncoder;
+        }
+        if (!globalObj.TextDecoder) {
+            globalObj.TextDecoder = TextDecoder;
+        }
+        // Also set the special global constructors that TensorFlow can use safely
+        ;
+        globalObj.__TextEncoder__ = TextEncoder;
+        globalObj.__TextDecoder__ = TextDecoder;
+        // Also patch process.versions to ensure TensorFlow.js detects Node.js correctly
+        if (typeof process !== 'undefined' && process.versions) {
+            // Ensure TensorFlow.js sees this as a Node.js environment
+            if (!process.versions.node) {
+                process.versions.node = process.version;
+            }
+        }
+        // CRITICAL: Patch the Node.js util module directly
+        try {
+            const util = await Promise.resolve().then(function () { return _utilShim$1; });
+            // Ensure TextEncoder and TextDecoder are available as constructors
+            util.TextEncoder = TextEncoder;
+            util.TextDecoder = TextDecoder;
         }
         catch (error) {
-            console.warn('Failed to apply TensorFlow.js platform patch:', error);
+            // Ignore if util module is not available
         }
+        patchApplied = true;
+    }
+    catch (error) {
+        console.warn('Brainy: Failed to apply TensorFlow.js platform patch:', error);
+    }
+}
+// Apply patch immediately
+applyTensorFlowPatch().catch((error) => {
+    console.warn('Failed to apply TensorFlow patch at module load:', error);
+});
+
+var textEncoding = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	applyTensorFlowPatch: applyTensorFlowPatch
+});
+
+/**
+ * CRITICAL: This file is imported for its side effects to patch the environment
+ * for TensorFlow.js before any other library code runs.
+ *
+ * It ensures that by the time TensorFlow.js is imported by any other
+ * module, the necessary compatibility fixes for the current Node.js
+ * environment are already in place.
+ *
+ * This file MUST be imported as the first import in unified.ts to prevent
+ * race conditions with TensorFlow.js initialization. Failure to do so will
+ * result in errors like "TextEncoder is not a constructor" when the package
+ * is used in Node.js environments.
+ *
+ * The package.json file marks this file as having side effects to prevent
+ * tree-shaking by bundlers, ensuring the patch is always applied.
+ */
+// Get the appropriate global object for the current environment
+const globalObj = (() => {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof global !== 'undefined')
+        return global;
+    if (typeof self !== 'undefined')
+        return self;
+    return null; // No global object available
+})();
+// Define TextEncoder and TextDecoder globally to make sure they're available
+// Now works across all environments: Node.js, serverless, and other server environments
+if (globalObj) {
+    if (!globalObj.TextEncoder) {
+        globalObj.TextEncoder = TextEncoder;
     }
+    if (!globalObj.TextDecoder) {
+        globalObj.TextDecoder = TextDecoder;
+    }
+    globalObj.__TextEncoder__ = TextEncoder;
+    globalObj.__TextDecoder__ = TextDecoder;
 }
+// Apply the TensorFlow.js platform patch
+applyTensorFlowPatch();
+console.log('Applied TensorFlow.js patch via ES modules in setup.ts');
 
 // 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
@@ -2683,12 +2948,31 @@ async function calculateDistancesBatch(queryVector, vectors, distanceFunction =
                     tf = await self.importTensorFlow();
                 }
                 else {
-                    // Dynamically import TensorFlow.js core module and backends
-                    tf = await Promise.resolve().then(function () { return index$2; });
-                    // Import CPU backend
-                    await Promise.resolve().then(function () { return index$1; });
-                    // Set CPU as the backend
-                    await tf.setBackend('cpu');
+                    // CRITICAL: Ensure TextEncoder/TextDecoder are available before TensorFlow.js loads
+                    try {
+                        // Use dynamic imports for all environments to ensure TensorFlow loads after patch
+                        if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+                            // Ensure TextEncoder/TextDecoder are globally available in Node.js
+                            const util = await Promise.resolve().then(function () { return _utilShim$1; });
+                            if (typeof global.TextEncoder === 'undefined') {
+                                global.TextEncoder = util.TextEncoder;
+                            }
+                            if (typeof global.TextDecoder === 'undefined') {
+                                global.TextDecoder = util.TextDecoder;
+                            }
+                        }
+                        // Apply the TensorFlow.js patch
+                        const { applyTensorFlowPatch } = await Promise.resolve().then(function () { return textEncoding; });
+                        await applyTensorFlowPatch();
+                        // Now load TensorFlow.js core module using dynamic imports
+                        tf = await Promise.resolve().then(function () { return index$2; });
+                        await Promise.resolve().then(function () { return index$1; });
+                        await tf.setBackend('cpu');
+                    }
+                    catch (error) {
+                        console.error('Failed to initialize TensorFlow.js:', error);
+                        throw error;
+                    }
                 }
                 // Convert vectors to tensors
                 const queryTensor = tf.tensor2d([queryVector]);
@@ -2800,76 +3084,6 @@ async function calculateDistancesBatch(queryVector, vectors, distanceFunction =
     }
 }
 
-/**
- * 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 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
- */
-function areWorkerThreadsAvailableSync() {
-    if (!isNode())
-        return false;
-    // In Node.js 24.3.0+, worker_threads is always available
-    return parseInt(process.versions.node.split('.')[0]) >= 24;
-}
-/**
- * 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() || 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)
  * This implementation leverages Node.js 24's improved Worker Threads API for better performance
@@ -2913,9 +3127,16 @@ function executeInThread(fnString, args) {
                         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);
+                        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);
+                        }
                     }
                 }
             }
@@ -2950,6 +3171,82 @@ function executeInNodeWorker(fnString, args) {
                     // 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 });
@@ -2969,6 +3266,71 @@ function executeInNodeWorker(fnString, args) {
                         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 });
@@ -3200,16 +3562,126 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
     }
     /**
      * Add polyfills and patches for TensorFlow.js compatibility
-     * This addresses issues with TensorFlow.js in Node.js environments
+     * This addresses issues with TensorFlow.js across all server environments
+     * (Node.js, serverless, and other server environments)
+     *
+     * Note: The main TensorFlow.js patching is now centralized in textEncoding.ts
+     * and applied through setup.ts. This method only adds additional utility functions
+     * that might be needed by TensorFlow.js.
      */
-    addNodeCompatibilityPolyfills() {
-        // Only apply in Node.js environment
-        if (typeof process === 'undefined' ||
-            !process.versions ||
-            !process.versions.node) {
-            return;
+    addServerCompatibilityPolyfills() {
+        // Apply in all non-browser environments (Node.js, serverless, server environments)
+        const isBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
+        if (isBrowserEnv) {
+            return; // Browser environments don't need these polyfills
+        }
+        // Get the appropriate global object for the current environment
+        const globalObj = (() => {
+            if (typeof globalThis !== 'undefined')
+                return globalThis;
+            if (typeof global !== 'undefined')
+                return global;
+            if (typeof self !== 'undefined')
+                return self;
+            return {}; // Fallback for unknown environments
+        })();
+        // Add polyfill for utility functions across all server environments
+        // This fixes issues like "Cannot read properties of undefined (reading 'isFloat32Array')"
+        try {
+            // Ensure the util object exists
+            if (!globalObj.util) {
+                globalObj.util = {};
+            }
+            // Add isFloat32Array method if it doesn't exist
+            if (!globalObj.util.isFloat32Array) {
+                globalObj.util.isFloat32Array = (obj) => {
+                    return !!(obj instanceof Float32Array ||
+                        (obj &&
+                            Object.prototype.toString.call(obj) === '[object Float32Array]'));
+                };
+            }
+            // Add isTypedArray method if it doesn't exist
+            if (!globalObj.util.isTypedArray) {
+                globalObj.util.isTypedArray = (obj) => {
+                    return !!(ArrayBuffer.isView(obj) && !(obj instanceof DataView));
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Failed to add utility polyfills:', error);
+        }
+    }
+    /**
+     * Check if we're running in a test environment
+     */
+    isTestEnvironment() {
+        // Safely check for Node.js environment first
+        if (typeof process === 'undefined') {
+            return false;
+        }
+        return (process.env.VITEST === 'true' ||
+            (typeof global !== 'undefined' && global.__vitest__) ||
+            process.argv.some((arg) => arg.includes('vitest')));
+    }
+    /**
+     * Log message only if not in test environment
+     */
+    logIfNotTest(level, message, ...args) {
+        if (!this.isTestEnvironment()) {
+            console[level](message, ...args);
+        }
+    }
+    /**
+     * Load the Universal Sentence Encoder model with retry logic
+     * This helps handle network failures and JSON parsing errors from TensorFlow Hub
+     * @param loadFunction The function to load the model
+     * @param maxRetries Maximum number of retry attempts
+     * @param baseDelay Base delay in milliseconds for exponential backoff
+     */
+    async loadModelWithRetry(loadFunction, maxRetries = 3, baseDelay = 1000) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                this.logIfNotTest('log', attempt === 0
+                    ? 'Loading Universal Sentence Encoder model...'
+                    : `Retrying Universal Sentence Encoder model loading (attempt ${attempt + 1}/${maxRetries + 1})...`);
+                const model = await loadFunction();
+                if (attempt > 0) {
+                    this.logIfNotTest('log', 'Universal Sentence Encoder model loaded successfully after retry');
+                }
+                return model;
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message || String(lastError);
+                // Check if this is a network-related error that might benefit from retry
+                const isRetryableError = errorMessage.includes('Failed to parse model JSON') ||
+                    errorMessage.includes('Failed to fetch') ||
+                    errorMessage.includes('Network error') ||
+                    errorMessage.includes('ENOTFOUND') ||
+                    errorMessage.includes('ECONNRESET') ||
+                    errorMessage.includes('ETIMEDOUT') ||
+                    errorMessage.includes('JSON') ||
+                    errorMessage.includes('model.json');
+                if (attempt < maxRetries && isRetryableError) {
+                    const delay = baseDelay * Math.pow(2, attempt); // Exponential backoff
+                    this.logIfNotTest('warn', `Universal Sentence Encoder model loading failed (attempt ${attempt + 1}): ${errorMessage}. Retrying in ${delay}ms...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    // Either we've exhausted retries or this is not a retryable error
+                    if (attempt >= maxRetries) {
+                        this.logIfNotTest('error', `Universal Sentence Encoder model loading failed after ${maxRetries + 1} attempts. Last error: ${errorMessage}`);
+                    }
+                    else {
+                        this.logIfNotTest('error', `Universal Sentence Encoder model loading failed with non-retryable error: ${errorMessage}`);
+                    }
+                    throw lastError;
+                }
+            }
         }
-        // No compatibility patches needed - TensorFlow.js now works correctly with Node.js 24+
+        // This should never be reached, but just in case
+        throw lastError || new Error('Unknown error during model loading');
     }
     /**
      * Initialize the embedding model
@@ -3228,43 +3700,87 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
                 originalWarn(message, ...optionalParams);
             };
             // Add polyfills for TensorFlow.js compatibility
-            this.addNodeCompatibilityPolyfills();
+            this.addServerCompatibilityPolyfills();
             // TensorFlow.js will use its default EPSILON value
-            // Dynamically import TensorFlow.js core module and backends
-            // Use type assertions to tell TypeScript these modules exist
-            this.tf = await Promise.resolve().then(function () { return index$2; });
-            // Import CPU backend (always needed as fallback)
-            await Promise.resolve().then(function () { return index$1; });
-            // Try to import WebGL backend for GPU acceleration in browser environments
+            // CRITICAL: Ensure TextEncoder/TextDecoder are available before TensorFlow.js loads
             try {
-                if (typeof window !== 'undefined') {
-                    await Promise.resolve().then(function () { return index; });
-                    // Check if WebGL is available using setBackend instead of findBackend
+                // Get the appropriate global object for the current environment
+                const globalObj = (() => {
+                    if (typeof globalThis !== 'undefined')
+                        return globalThis;
+                    if (typeof global !== 'undefined')
+                        return global;
+                    if (typeof self !== 'undefined')
+                        return self;
+                    return null;
+                })();
+                // Ensure TextEncoder/TextDecoder are globally available in server environments
+                if (globalObj) {
+                    // Try to use Node.js util module if available (Node.js environments)
                     try {
-                        if (this.tf.setBackend) {
-                            await this.tf.setBackend('webgl');
-                            this.backend = 'webgl';
-                            console.log('Using WebGL backend for TensorFlow.js');
+                        if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+                            const util = await Promise.resolve().then(function () { return _utilShim$1; });
+                            if (!globalObj.TextEncoder) {
+                                globalObj.TextEncoder = util.TextEncoder;
+                            }
+                            if (!globalObj.TextDecoder) {
+                                globalObj.TextDecoder = util.TextDecoder;
+                            }
                         }
-                        else {
-                            console.warn('tf.setBackend is not available, falling back to CPU');
+                    }
+                    catch (utilError) {
+                        // Fallback to standard TextEncoder/TextDecoder for non-Node.js server environments
+                        if (!globalObj.TextEncoder) {
+                            globalObj.TextEncoder = TextEncoder;
+                        }
+                        if (!globalObj.TextDecoder) {
+                            globalObj.TextDecoder = TextDecoder;
                         }
                     }
-                    catch (e) {
-                        console.warn('WebGL backend not available, falling back to CPU:', e);
-                        this.backend = 'cpu';
+                }
+                // Apply the TensorFlow.js patch
+                const { applyTensorFlowPatch } = await Promise.resolve().then(function () { return textEncoding; });
+                await applyTensorFlowPatch();
+                // Now load TensorFlow.js core module using dynamic imports
+                this.tf = await Promise.resolve().then(function () { return index$2; });
+                // Import CPU backend (always needed as fallback)
+                await Promise.resolve().then(function () { return index$1; });
+                // Try to import WebGL backend for GPU acceleration in browser environments
+                try {
+                    if (typeof window !== 'undefined') {
+                        await Promise.resolve().then(function () { return index; });
+                        // Check if WebGL is available
+                        try {
+                            if (this.tf.setBackend) {
+                                await this.tf.setBackend('webgl');
+                                this.backend = 'webgl';
+                                console.log('Using WebGL backend for TensorFlow.js');
+                            }
+                            else {
+                                console.warn('tf.setBackend is not available, falling back to CPU');
+                            }
+                        }
+                        catch (e) {
+                            console.warn('WebGL backend not available, falling back to CPU:', e);
+                            this.backend = 'cpu';
+                        }
                     }
                 }
+                catch (error) {
+                    console.warn('WebGL backend not available, falling back to CPU:', error);
+                    this.backend = 'cpu';
+                }
+                // Load Universal Sentence Encoder using dynamic import
+                this.use = await Promise.resolve().then(function () { return universalSentenceEncoder_esm; });
             }
             catch (error) {
-                console.warn('WebGL backend not available, falling back to CPU:', error);
-                this.backend = 'cpu';
+                this.logIfNotTest('error', 'Failed to initialize TensorFlow.js:', error);
+                throw error;
             }
             // Set the backend
             if (this.tf.setBackend) {
                 await this.tf.setBackend(this.backend);
             }
-            this.use = await Promise.resolve().then(function () { return universalSentenceEncoder_esm; });
             // Log the module structure to help with debugging
             console.log('Universal Sentence Encoder module structure in main thread:', Object.keys(this.use), this.use.default ? Object.keys(this.use.default) : 'No default export');
             // Try to find the load function in different possible module structures
@@ -3272,14 +3788,14 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
             if (!loadFunction) {
                 throw new Error('Could not find Universal Sentence Encoder load function');
             }
-            // Load the model
-            this.model = await loadFunction();
+            // Load the model with retry logic for network failures
+            this.model = await this.loadModelWithRetry(loadFunction);
             this.initialized = true;
             // Restore original console.warn
             console.warn = originalWarn;
         }
         catch (error) {
-            console.error('Failed to initialize Universal Sentence Encoder:', error);
+            this.logIfNotTest('error', 'Failed to initialize Universal Sentence Encoder:', error);
             throw new Error(`Failed to initialize Universal Sentence Encoder: ${error}`);
         }
     }
@@ -3326,7 +3842,7 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
             return embeddingArray[0];
         }
         catch (error) {
-            console.error('Failed to embed text with Universal Sentence Encoder:', error);
+            this.logIfNotTest('error', 'Failed to embed text with Universal Sentence Encoder:', error);
             throw new Error(`Failed to embed text with Universal Sentence Encoder: ${error}`);
         }
     }
@@ -3375,7 +3891,7 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
             return results;
         }
         catch (error) {
-            console.error('Failed to batch embed text with Universal Sentence Encoder:', error);
+            this.logIfNotTest('error', 'Failed to batch embed text with Universal Sentence Encoder:', error);
             throw new Error(`Failed to batch embed text with Universal Sentence Encoder: ${error}`);
         }
     }
@@ -3391,7 +3907,7 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
                 this.initialized = false;
             }
             catch (error) {
-                console.error('Failed to dispose Universal Sentence Encoder:', error);
+                this.logIfNotTest('error', 'Failed to dispose Universal Sentence Encoder:', error);
             }
         }
         return Promise.resolve();
@@ -3479,11 +3995,35 @@ function findUSELoadFunction(sentenceEncoderModule) {
     }
     return loadFunction;
 }
+/**
+ * Check if we're running in a test environment (standalone version)
+ */
+function isTestEnvironment() {
+    // Safely check for Node.js environment first
+    if (typeof process === 'undefined') {
+        return false;
+    }
+    return (process.env.VITEST === 'true' ||
+        (typeof global !== 'undefined' && global.__vitest__) ||
+        process.argv.some((arg) => arg.includes('vitest')));
+}
+/**
+ * Log message only if not in test environment (standalone version)
+ */
+function logIfNotTest(level, message, ...args) {
+    if (!isTestEnvironment()) {
+        console[level](message, ...args);
+    }
+}
 /**
  * Create an embedding function from an embedding model
- * @param model Embedding model to use
+ * @param model Embedding model to use (optional, defaults to UniversalSentenceEncoder)
  */
 function createEmbeddingFunction(model) {
+    // If no model is provided, use the default TensorFlow embedding function
+    if (!model) {
+        return createTensorFlowEmbeddingFunction();
+    }
     return async (data) => {
         return await model.embed(data);
     };
@@ -3501,13 +4041,20 @@ function createTensorFlowEmbeddingFunction() {
         try {
             // Initialize the model if it hasn't been initialized yet
             if (!sharedModelInitialized) {
-                await sharedModel.init();
-                sharedModelInitialized = true;
+                try {
+                    await sharedModel.init();
+                    sharedModelInitialized = true;
+                }
+                catch (initError) {
+                    // Reset the flag so we can retry initialization on the next call
+                    sharedModelInitialized = false;
+                    throw initError;
+                }
             }
             return await sharedModel.embed(data);
         }
         catch (error) {
-            console.error('Failed to use TensorFlow embedding:', error);
+            logIfNotTest('error', 'Failed to use TensorFlow embedding:', error);
             throw new Error(`Universal Sentence Encoder is required but failed: ${error}`);
         }
     };
@@ -3539,7 +4086,7 @@ const defaultBatchEmbeddingFunction = async (dataArray) => {
         return await sharedBatchModel.embedBatch(dataArray);
     }
     catch (error) {
-        console.error('Failed to use TensorFlow batch embedding:', error);
+        logIfNotTest('error', 'Failed to use TensorFlow batch embedding:', error);
         throw new Error(`Universal Sentence Encoder batch embedding failed: ${error}`);
     }
 };
@@ -7916,6 +8463,26 @@ async function createServerSearchAugmentations(serverUrl, options = {}) {
  * Main class that provides the vector database functionality
  */
 class BrainyData {
+    /**
+     * Get the vector dimensions
+     */
+    get dimensions() {
+        return this._dimensions;
+    }
+    /**
+     * Get the maximum connections parameter from HNSW configuration
+     */
+    get maxConnections() {
+        const config = this.index.getConfig();
+        return config.M || 16;
+    }
+    /**
+     * Get the efConstruction parameter from HNSW configuration
+     */
+    get efConstruction() {
+        const config = this.index.getConfig();
+        return config.efConstruction || 200;
+    }
     /**
      * Create a new vector database
      */
@@ -7929,6 +8496,12 @@ class BrainyData {
         this.remoteServerConfig = null;
         this.serverSearchConduit = null;
         this.serverConnection = null;
+        // Validate dimensions
+        if (config.dimensions !== undefined && config.dimensions <= 0) {
+            throw new Error('Dimensions must be a positive number');
+        }
+        // Set dimensions (default to 512 for embedding functions, or require explicit config)
+        this._dimensions = config.dimensions || 512;
         // Set distance function
         this.distanceFunction = config.distanceFunction || cosineDistance$1;
         // Check if optimized HNSW index configuration is provided
@@ -8032,6 +8605,13 @@ class BrainyData {
             // Clear the index and add all nouns
             this.index.clear();
             for (const noun of nouns) {
+                // Check if the vector dimensions match the expected dimensions
+                if (noun.vector.length !== this._dimensions) {
+                    console.warn(`Skipping noun ${noun.id} due to dimension mismatch: expected ${this._dimensions}, got ${noun.vector.length}`);
+                    // Optionally, you could delete the mismatched noun from storage
+                    // await this.storage!.deleteNoun(noun.id)
+                    continue;
+                }
                 // Add to index
                 await this.index.addItem({
                     id: noun.id,
@@ -8115,6 +8695,10 @@ class BrainyData {
             if (!vector) {
                 throw new Error('Vector is undefined or null');
             }
+            // Validate vector dimensions
+            if (vector.length !== this._dimensions) {
+                throw new Error(`Vector dimension mismatch: expected ${this._dimensions}, got ${vector.length}`);
+            }
             // Use ID from options if it exists, otherwise from metadata, otherwise generate a new UUID
             const id = options.id ||
                 (metadata && typeof metadata === 'object' && 'id' in metadata
@@ -8141,7 +8725,12 @@ class BrainyData {
                         metadata.noun = NounType.Concept;
                     }
                 }
-                await this.storage.saveMetadata(id, metadata);
+                // Ensure metadata has the correct id field
+                let metadataToSave = metadata;
+                if (metadata && typeof metadata === 'object') {
+                    metadataToSave = { ...metadata, id };
+                }
+                await this.storage.saveMetadata(id, metadataToSave);
             }
             // If addToRemote is true and we're connected to a remote server, add to remote as well
             if (options.addToRemote && this.isConnectedToRemoteServer()) {
@@ -8159,6 +8748,18 @@ class BrainyData {
             throw new Error(`Failed to add vector: ${error}`);
         }
     }
+    /**
+     * Add a text item to the database with automatic embedding
+     * This is a convenience method for adding text data with metadata
+     * @param text Text data to add
+     * @param metadata Metadata to associate with the text
+     * @param options Additional options
+     * @returns The ID of the added item
+     */
+    async addItem(text, metadata, options = {}) {
+        // Use the existing add method with forceEmbed to ensure text is embedded
+        return this.add(text, metadata, { ...options, forceEmbed: true });
+    }
     /**
      * Add data to both local and remote Brainy instances
      * @param vectorOrData Vector or data to add
@@ -8310,7 +8911,9 @@ class BrainyData {
      * @returns Array of search results
      */
     async searchByNounTypes(queryVectorOrData, k = 10, nounTypes = null, options = {}) {
-        await this.ensureInitialized();
+        if (!this.isInitialized) {
+            throw new Error('BrainyData must be initialized before searching. Call init() first.');
+        }
         try {
             let queryVector;
             // Check if input is already a vector
@@ -8404,6 +9007,9 @@ class BrainyData {
      * @returns Array of search results
      */
     async search(queryVectorOrData, k = 10, options = {}) {
+        if (!this.isInitialized) {
+            throw new Error('BrainyData must be initialized before searching. Call init() first.');
+        }
         // If searching for verbs directly
         if (options.searchVerbs) {
             const verbResults = await this.searchVerbs(queryVectorOrData, k, {
@@ -8452,6 +9058,9 @@ class BrainyData {
      * @returns Array of search results
      */
     async searchLocal(queryVectorOrData, k = 10, options = {}) {
+        if (!this.isInitialized) {
+            throw new Error('BrainyData must be initialized before searching. Call init() first.');
+        }
         // If input is a string and not a vector, automatically vectorize it
         let queryToUse = queryVectorOrData;
         if (typeof queryVectorOrData === 'string' && !options.forceEmbed) {
@@ -9625,12 +10234,40 @@ class BrainyData {
     }
 }
 
-// Import Node.js built-in modules
-// Using dynamic imports for compatibility with ES modules
+// Dynamically and asynchronously load Node.js modules at the top level.
+// This ensures they are available as soon as this module is imported,
+// preventing race conditions with dependencies like TensorFlow.js.
 let fs;
 let path;
-// We'll initialize these modules in the init() method
-// No synchronous loading here to avoid issues with ES modules
+const nodeModulesPromise = (async () => {
+    // A reliable check for a Node.js environment.
+    const isNode = typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null;
+    if (!isNode) {
+        return { fs: null, path: null };
+    }
+    try {
+        // Use the 'node:' prefix for unambiguous importing of built-in modules.
+        const fsModule = await import('node:fs');
+        const pathModule = await import('node:path');
+        // Return the modules, preferring the default export if it exists.
+        return {
+            fs: fsModule.default || fsModule,
+            path: pathModule.default || pathModule
+        };
+    }
+    catch (error) {
+        console.error('FileSystemStorage: Failed to load Node.js modules. This adapter is not supported in this environment.', error);
+        return { fs: null, path: null };
+    }
+})();
+// Immediately assign the modules once the promise resolves.
+nodeModulesPromise.then((modules) => {
+    fs = modules.fs;
+    path = modules.path;
+});
+// --- End of Refactored Code ---
 // Constants for directory and file names
 const ROOT_DIR = 'brainy-data';
 const NOUNS_DIR = 'nouns';
@@ -9670,58 +10307,13 @@ class FileSystemStorage {
         if (this.isInitialized) {
             return;
         }
+        // Wait for the top-level module loading to complete.
+        await nodeModulesPromise;
+        // Check if the modules were loaded successfully.
+        if (!fs || !path) {
+            throw new Error('FileSystemStorage requires a Node.js environment, but `fs` and `path` modules could not be loaded.');
+        }
         try {
-            // Check if fs and path modules are available and have required methods
-            if (!fs || !path || typeof path.resolve !== 'function') {
-                console.log('Node.js modules not properly loaded, attempting to load them now');
-                // Try multiple approaches to load the modules
-                const loadAttempts = [
-                    // Attempt 1: Use dynamic import
-                    async () => {
-                        console.log('Attempting to load Node.js modules with dynamic import');
-                        const fsModule = await import('fs');
-                        const pathModule = await import('path');
-                        const fsResolved = fsModule.default || fsModule;
-                        const pathResolved = pathModule.default || pathModule;
-                        if (!pathResolved || typeof pathResolved.resolve !== 'function') {
-                            throw new Error('path.resolve is not a function after dynamic import');
-                        }
-                        return { fs: fsResolved, path: pathResolved };
-                    },
-                    // Attempt 2: Use dynamic import with node: prefix
-                    async () => {
-                        console.log('Attempting to load Node.js modules with dynamic import("node:...")');
-                        const fsModule = await import('node:fs');
-                        const pathModule = await import('node:path');
-                        const fsResolved = fsModule.default || fsModule;
-                        const pathResolved = pathModule.default || pathModule;
-                        if (!pathResolved || typeof pathResolved.resolve !== 'function') {
-                            throw new Error('path.resolve is not a function after dynamic import("node:path")');
-                        }
-                        return { fs: fsResolved, path: pathResolved };
-                    }
-                ];
-                // Try each loading method until one succeeds
-                let lastError = null;
-                for (const loadAttempt of loadAttempts) {
-                    try {
-                        const modules = await loadAttempt();
-                        fs = modules.fs;
-                        path = modules.path;
-                        console.log('Successfully loaded Node.js modules');
-                        break;
-                    }
-                    catch (error) {
-                        lastError = error;
-                        console.warn(`Module loading attempt failed:`, error);
-                        // Continue to the next attempt
-                    }
-                }
-                // If all attempts failed, throw an error
-                if (!fs || !path || typeof path.resolve !== 'function') {
-                    throw new Error(`Failed to import Node.js modules after multiple attempts: ${lastError}. This adapter requires a Node.js environment.`);
-                }
-            }
             // Now set up the directory paths
             const rootDir = this.rootDir || process.cwd();
             this.rootDir = path.resolve(rootDir, ROOT_DIR);
@@ -9741,7 +10333,6 @@ class FileSystemStorage {
             await this.ensureDirectoryExists(this.nounsDir);
             await this.ensureDirectoryExists(this.verbsDir);
             await this.ensureDirectoryExists(this.metadataDir);
-            // Create noun type directories
             await this.ensureDirectoryExists(this.personDir);
             await this.ensureDirectoryExists(this.placeDir);
             await this.ensureDirectoryExists(this.thingDir);
@@ -9752,736 +10343,403 @@ class FileSystemStorage {
             this.isInitialized = true;
         }
         catch (error) {
-            console.error('Failed to initialize file system storage:', error);
-            throw new Error(`Failed to initialize file system storage: ${error}`);
+            console.error('Error initializing FileSystemStorage:', error);
+            throw error;
         }
     }
-    /**
-     * Save a node to storage
-     */
-    async saveNoun(noun) {
-        await this.ensureInitialized();
+    async ensureDirectoryExists(dirPath) {
         try {
-            // Convert connections Map to a serializable format
-            const serializableNode = {
-                ...noun,
-                connections: this.mapToObject(noun.connections, (set) => Array.from(set))
-            };
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(noun.id);
-            const filePath = path.join(nodeDir, `${noun.id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(serializableNode, null, 2), 'utf8');
+            await fs.promises.mkdir(dirPath, { recursive: true });
         }
         catch (error) {
-            console.error(`Failed to save node ${noun.id}:`, error);
-            throw new Error(`Failed to save node ${noun.id}: ${error}`);
-        }
-    }
-    /**
-     * Get a node from storage
-     */
-    async getNoun(id) {
-        await this.ensureInitialized();
-        try {
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(id);
-            const filePath = path.join(nodeDir, `${id}.json`);
-            // Check if a file exists
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                // If the file doesn't exist in the expected directory, try the default directory
-                if (nodeDir !== this.defaultDir) {
-                    const defaultFilePath = path.join(this.defaultDir, `${id}.json`);
-                    try {
-                        await fs.promises.access(defaultFilePath);
-                        // If found in default directory, use that path
-                        const data = await fs.promises.readFile(defaultFilePath, 'utf8');
-                        const parsedNode = JSON.parse(data);
-                        // Convert serialized connections back to Map<number, Set<string>>
-                        const connections = new Map();
-                        for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                            connections.set(Number(level), new Set(nodeIds));
-                        }
-                        return {
-                            id: parsedNode.id,
-                            vector: parsedNode.vector,
-                            connections
-                        };
-                    }
-                    catch {
-                        // If not found in default directory either, try all noun type directories
-                        const directories = [
-                            this.personDir,
-                            this.placeDir,
-                            this.thingDir,
-                            this.eventDir,
-                            this.conceptDir,
-                            this.contentDir
-                        ];
-                        for (const dir of directories) {
-                            if (dir === nodeDir)
-                                continue; // Skip the already checked directory
-                            const dirFilePath = path.join(dir, `${id}.json`);
-                            try {
-                                await fs.promises.access(dirFilePath);
-                                // If found in this directory, use that path
-                                const data = await fs.promises.readFile(dirFilePath, 'utf8');
-                                const parsedNode = JSON.parse(data);
-                                // Convert serialized connections back to Map<number, Set<string>>
-                                const connections = new Map();
-                                for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                                    connections.set(Number(level), new Set(nodeIds));
-                                }
-                                return {
-                                    id: parsedNode.id,
-                                    vector: parsedNode.vector,
-                                    connections
-                                };
-                            }
-                            catch {
-                                // Continue to the next directory
-                            }
-                        }
-                        return null; // File doesn't exist in any directory
-                    }
-                }
-                return null; // File doesn't exist
-            }
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedNode = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+            // Ignore EEXIST error, which means the directory already exists
+            if (error.code !== 'EEXIST') {
+                throw error;
             }
-            return {
-                id: parsedNode.id,
-                vector: parsedNode.vector,
-                connections
-            };
-        }
-        catch (error) {
-            console.error(`Failed to get node ${id}:`, error);
-            return null;
         }
     }
-    /**
-     * Get nodes by noun type
-     * @param nounType The noun type to filter by
-     * @returns Promise that resolves to an array of nodes of the specified noun type
-     */
-    async getNounsByNounType(nounType) {
-        await this.ensureInitialized();
-        try {
-            // Determine the directory based on the noun type
-            let dir;
-            switch (nounType) {
+    getNounPath(id, nounType) {
+        let typeDir = this.defaultDir;
+        if (nounType) {
+            switch (nounType.toLowerCase()) {
                 case 'person':
-                    dir = this.personDir;
+                    typeDir = this.personDir;
                     break;
                 case 'place':
-                    dir = this.placeDir;
+                    typeDir = this.placeDir;
                     break;
                 case 'thing':
-                    dir = this.thingDir;
+                    typeDir = this.thingDir;
                     break;
                 case 'event':
-                    dir = this.eventDir;
+                    typeDir = this.eventDir;
                     break;
                 case 'concept':
-                    dir = this.conceptDir;
+                    typeDir = this.conceptDir;
                     break;
                 case 'content':
-                    dir = this.contentDir;
+                    typeDir = this.contentDir;
                     break;
                 default:
-                    dir = this.defaultDir;
-            }
-            const nodes = [];
-            try {
-                const files = await fs.promises.readdir(dir);
-                const nodePromises = files
-                    .filter((file) => file.endsWith('.json'))
-                    .map((file) => {
-                    // Use the file path directly instead of getNode to avoid redundant searches
-                    return this.readNodeFromFile(path.join(dir, file));
-                });
-                const dirNodes = await Promise.all(nodePromises);
-                nodes.push(...dirNodes.filter((node) => node !== null));
-            }
-            catch (dirError) {
-                // If directory doesn't exist or can't be read, log a warning
-                console.warn(`Could not read directory for noun type ${nounType}:`, dirError);
+                    typeDir = this.defaultDir;
             }
-            return nodes;
-        }
-        catch (error) {
-            console.error(`Failed to get nodes for noun type ${nounType}:`, error);
-            throw new Error(`Failed to get nodes for noun type ${nounType}: ${error}`);
         }
+        return path.join(typeDir, `${id}.json`);
     }
-    /**
-     * Get all nodes from storage
-     */
-    async getAllNouns() {
-        await this.ensureInitialized();
-        try {
-            // Get all noun types
-            const nounTypes = [
-                'person',
-                'place',
-                'thing',
-                'event',
-                'concept',
-                'content',
-                'default'
-            ];
-            // Run searches in parallel for all noun types
-            const nodePromises = nounTypes.map((nounType) => this.getNounsByNounType(nounType));
-            const nodeArrays = await Promise.all(nodePromises);
-            // Combine all results
-            const allNodes = [];
-            for (const nodes of nodeArrays) {
-                allNodes.push(...nodes);
-            }
-            return allNodes;
-        }
-        catch (error) {
-            console.error('Failed to get all nodes:', error);
-            throw new Error(`Failed to get all nodes: ${error}`);
-        }
+    async saveNoun(noun) {
+        if (!this.isInitialized)
+            await this.init();
+        const nounType = noun.metadata?.noun;
+        const filePath = this.getNounPath(noun.id, nounType);
+        await this.ensureDirectoryExists(path.dirname(filePath));
+        await fs.promises.writeFile(filePath, JSON.stringify(noun, null, 2));
     }
-    /**
-     * Read a node from a file
-     */
-    async readNodeFromFile(filePath) {
-        try {
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedNode = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+    async getNoun(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const nounDirs = [
+            this.personDir,
+            this.placeDir,
+            this.thingDir,
+            this.eventDir,
+            this.conceptDir,
+            this.contentDir,
+            this.defaultDir
+        ];
+        for (const dir of nounDirs) {
+            const filePath = path.join(dir, `${id}.json`);
+            try {
+                const data = await fs.promises.readFile(filePath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error reading noun ${id}:`, error);
+                }
             }
-            return {
-                id: parsedNode.id,
-                vector: parsedNode.vector,
-                connections
-            };
-        }
-        catch (error) {
-            console.error(`Failed to read node from file ${filePath}:`, error);
-            return null;
         }
+        return null;
     }
-    /**
-     * Delete a node from storage
-     */
     async deleteNoun(id) {
-        await this.ensureInitialized();
-        try {
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(id);
-            const filePath = path.join(nodeDir, `${id}.json`);
-            // Check if a file exists before attempting to delete
+        if (!this.isInitialized)
+            await this.init();
+        const noun = await this.getNoun(id);
+        if (noun) {
+            const nounType = noun.metadata?.noun;
+            const filePath = this.getNounPath(id, nounType);
             try {
-                await fs.promises.access(filePath);
                 await fs.promises.unlink(filePath);
-                return; // File found and deleted
             }
-            catch {
-                // If the file doesn't exist in the expected directory, try the default directory
-                if (nodeDir !== this.defaultDir) {
-                    const defaultFilePath = path.join(this.defaultDir, `${id}.json`);
-                    try {
-                        await fs.promises.access(defaultFilePath);
-                        await fs.promises.unlink(defaultFilePath);
-                        return; // File found and deleted
-                    }
-                    catch {
-                        // If not found in default directory either, try all noun type directories
-                        const directories = [
-                            this.personDir,
-                            this.placeDir,
-                            this.thingDir,
-                            this.eventDir,
-                            this.conceptDir,
-                            this.contentDir
-                        ];
-                        for (const dir of directories) {
-                            if (dir === nodeDir)
-                                continue; // Skip the already checked directory
-                            const dirFilePath = path.join(dir, `${id}.json`);
-                            try {
-                                await fs.promises.access(dirFilePath);
-                                await fs.promises.unlink(dirFilePath);
-                                return; // File found and deleted
-                            }
-                            catch {
-                                // Continue to the next directory
-                            }
-                        }
-                        return; // File doesn't exist in any directory, nothing to delete
-                    }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error deleting noun file ${filePath}:`, error);
+                    throw error;
                 }
-                return; // File doesn't exist, nothing to delete
             }
         }
-        catch (error) {
-            console.error(`Failed to delete node ${id}:`, error);
-            throw new Error(`Failed to delete node ${id}: ${error}`);
-        }
-    }
-    /**
-     * Save an edge to storage
-     */
-    async saveVerb(verb) {
-        await this.ensureInitialized();
-        try {
-            // Convert connections Map to a serializable format
-            const serializableEdge = {
-                ...verb,
-                connections: this.mapToObject(verb.connections, (set) => Array.from(set))
-            };
-            const filePath = path.join(this.verbsDir, `${verb.id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(serializableEdge, null, 2), 'utf8');
-        }
-        catch (error) {
-            console.error(`Failed to save edge ${verb.id}:`, error);
-            throw new Error(`Failed to save edge ${verb.id}: ${error}`);
-        }
     }
-    /**
-     * Get an edge from storage
-     */
-    async getVerb(id) {
-        await this.ensureInitialized();
-        try {
-            const filePath = path.join(this.verbsDir, `${id}.json`);
-            // Check if a file exists
+    async getAllNouns() {
+        if (!this.isInitialized)
+            await this.init();
+        const allNouns = [];
+        const nounDirs = [
+            this.personDir,
+            this.placeDir,
+            this.thingDir,
+            this.eventDir,
+            this.conceptDir,
+            this.contentDir,
+            this.defaultDir
+        ];
+        for (const dir of nounDirs) {
             try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return null; // File doesn't exist
+                const files = await fs.promises.readdir(dir);
+                for (const file of files) {
+                    if (file.endsWith('.json')) {
+                        const filePath = path.join(dir, file);
+                        const data = await fs.promises.readFile(filePath, 'utf-8');
+                        allNouns.push(JSON.parse(data));
+                    }
+                }
             }
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedEdge = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error reading directory ${dir}:`, error);
+                }
             }
-            return {
-                id: parsedEdge.id,
-                vector: parsedEdge.vector,
-                connections,
-                sourceId: parsedEdge.sourceId,
-                targetId: parsedEdge.targetId,
-                type: parsedEdge.type,
-                weight: parsedEdge.weight,
-                metadata: parsedEdge.metadata
-            };
-        }
-        catch (error) {
-            console.error(`Failed to get edge ${id}:`, error);
-            return null;
         }
+        return allNouns;
     }
     /**
-     * Get all edges from storage
+     * Get nouns by noun type
+     * @param nounType The noun type to filter by
+     * @returns Promise that resolves to an array of nouns of the specified noun type
      */
-    async getAllVerbs() {
-        await this.ensureInitialized();
+    async getNounsByNounType(nounType) {
+        if (!this.isInitialized)
+            await this.init();
+        let typeDir;
+        switch (nounType.toLowerCase()) {
+            case 'person':
+                typeDir = this.personDir;
+                break;
+            case 'place':
+                typeDir = this.placeDir;
+                break;
+            case 'thing':
+                typeDir = this.thingDir;
+                break;
+            case 'event':
+                typeDir = this.eventDir;
+                break;
+            case 'concept':
+                typeDir = this.conceptDir;
+                break;
+            case 'content':
+                typeDir = this.contentDir;
+                break;
+            default:
+                typeDir = this.defaultDir;
+        }
+        const nouns = [];
         try {
-            const files = await fs.promises.readdir(this.verbsDir);
-            const edgePromises = files
-                .filter((file) => file.endsWith('.json'))
-                .map((file) => {
-                const id = path.basename(file, '.json');
-                return this.getVerb(id);
-            });
-            const edges = await Promise.all(edgePromises);
-            return edges.filter((edge) => edge !== null);
+            const files = await fs.promises.readdir(typeDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(typeDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    nouns.push(JSON.parse(data));
+                }
+            }
         }
         catch (error) {
-            console.error('Failed to get all edges:', error);
-            throw new Error(`Failed to get all edges: ${error}`);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading directory ${typeDir}:`, error);
+            }
         }
+        return nouns;
+    }
+    async saveVerb(verb) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${verb.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(verb, null, 2));
     }
     /**
-     * Get edges by source node ID
+     * Get a verb by its ID
+     * @param id The ID of the verb to retrieve
+     * @returns Promise that resolves to the verb or null if not found
      */
-    async getVerbsBySource(sourceId) {
-        await this.ensureInitialized();
+    async getVerb(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
         try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.sourceId === sourceId);
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
         }
         catch (error) {
-            console.error(`Failed to get edges by source ${sourceId}:`, error);
-            throw new Error(`Failed to get edges by source ${sourceId}: ${error}`);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading verb ${id}:`, error);
+            }
+            return null;
         }
     }
+    async getVerbsBySource(sourceId) {
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.sourceId === sourceId);
+    }
     /**
-     * Get edges by target node ID
+     * Get verbs by target ID
+     * @param targetId The target ID to filter by
+     * @returns Promise that resolves to an array of verbs with the specified target ID
      */
     async getVerbsByTarget(targetId) {
-        await this.ensureInitialized();
-        try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.targetId === targetId);
-        }
-        catch (error) {
-            console.error(`Failed to get edges by target ${targetId}:`, error);
-            throw new Error(`Failed to get edges by target ${targetId}: ${error}`);
-        }
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.targetId === targetId);
     }
     /**
-     * Get edges by type
+     * Get verbs by type
+     * @param type The verb type to filter by
+     * @returns Promise that resolves to an array of verbs of the specified type
      */
     async getVerbsByType(type) {
-        await this.ensureInitialized();
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.type === type);
+    }
+    async getAllVerbs() {
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = [];
         try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.type === type);
+            const files = await fs.promises.readdir(this.verbsDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.verbsDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    allVerbs.push(JSON.parse(data));
+                }
+            }
         }
         catch (error) {
-            console.error(`Failed to get edges by type ${type}:`, error);
-            throw new Error(`Failed to get edges by type ${type}: ${error}`);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading verbs directory ${this.verbsDir}:`, error);
+            }
         }
+        return allVerbs;
     }
-    /**
-     * Delete an edge from storage
-     */
     async deleteVerb(id) {
-        await this.ensureInitialized();
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
         try {
-            const filePath = path.join(this.verbsDir, `${id}.json`);
-            // Check if a file exists before attempting to delete
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return; // File doesn't exist, nothing to delete
-            }
             await fs.promises.unlink(filePath);
         }
         catch (error) {
-            console.error(`Failed to delete edge ${id}:`, error);
-            throw new Error(`Failed to delete edge ${id}: ${error}`);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error deleting verb file ${filePath}:`, error);
+                throw error;
+            }
         }
     }
     /**
-     * Save metadata to storage
+     * Save metadata for an entity
+     * @param id The ID of the entity
+     * @param metadata The metadata to save
      */
     async saveMetadata(id, metadata) {
-        await this.ensureInitialized();
-        try {
-            const filePath = path.join(this.metadataDir, `${id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2), 'utf8');
-        }
-        catch (error) {
-            console.error(`Failed to save metadata for ${id}:`, error);
-            throw new Error(`Failed to save metadata for ${id}: ${error}`);
-        }
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
+        await this.ensureDirectoryExists(path.dirname(filePath));
+        await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2));
     }
     /**
-     * Get metadata from storage
+     * Get metadata for an entity
+     * @param id The ID of the entity
+     * @returns Promise that resolves to the metadata or null if not found
      */
     async getMetadata(id) {
-        await this.ensureInitialized();
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
         try {
-            const filePath = path.join(this.metadataDir, `${id}.json`);
-            // Check if a file exists
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return null; // File doesn't exist
-            }
-            const data = await fs.promises.readFile(filePath, 'utf8');
+            const data = await fs.promises.readFile(filePath, 'utf-8');
             return JSON.parse(data);
         }
         catch (error) {
-            console.error(`Failed to get metadata for ${id}:`, error);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading metadata for ${id}:`, error);
+            }
             return null;
         }
     }
-    /**
-     * Clear all data from storage
-     */
     async clear() {
-        await this.ensureInitialized();
-        try {
-            // Delete and recreate the nodes, edges, and metadata directories
-            await this.deleteDirectory(this.nounsDir);
-            await this.deleteDirectory(this.verbsDir);
-            await this.deleteDirectory(this.metadataDir);
-            await this.ensureDirectoryExists(this.nounsDir);
-            await this.ensureDirectoryExists(this.verbsDir);
-            await this.ensureDirectoryExists(this.metadataDir);
-            // Create noun type directories
-            await this.ensureDirectoryExists(this.personDir);
-            await this.ensureDirectoryExists(this.placeDir);
-            await this.ensureDirectoryExists(this.thingDir);
-            await this.ensureDirectoryExists(this.eventDir);
-            await this.ensureDirectoryExists(this.conceptDir);
-            await this.ensureDirectoryExists(this.contentDir);
-            await this.ensureDirectoryExists(this.defaultDir);
-        }
-        catch (error) {
-            console.error('Failed to clear storage:', error);
-            throw new Error(`Failed to clear storage: ${error}`);
-        }
-    }
-    /**
-     * Ensure the storage adapter is initialized
-     */
-    async ensureInitialized() {
-        if (!this.isInitialized) {
+        if (!this.isInitialized)
             await this.init();
-        }
-    }
-    /**
-     * Ensure a directory exists, creating it if necessary
-     */
-    async ensureDirectoryExists(dirPath) {
-        try {
-            await fs.promises.access(dirPath);
-        }
-        catch {
-            // Directory doesn't exist, create it
-            await fs.promises.mkdir(dirPath, { recursive: true });
-        }
-    }
-    /**
-     * Delete a directory and all its contents recursively
-     */
-    async deleteDirectory(dirPath) {
-        try {
-            const files = await fs.promises.readdir(dirPath);
-            for (const file of files) {
-                const filePath = path.join(dirPath, file);
-                const stats = await fs.promises.stat(filePath);
-                if (stats.isDirectory()) {
-                    // Recursively delete subdirectories
-                    await this.deleteDirectory(filePath);
-                }
-                else {
-                    // Delete files
-                    await fs.promises.unlink(filePath);
+        // Helper function to recursively remove directory contents
+        const removeDirectoryContents = async (dirPath) => {
+            try {
+                const files = await fs.promises.readdir(dirPath, { withFileTypes: true });
+                for (const file of files) {
+                    const fullPath = path.join(dirPath, file.name);
+                    if (file.isDirectory()) {
+                        await removeDirectoryContents(fullPath);
+                        // Use fs.promises.rm with recursive option instead of rmdir
+                        try {
+                            await fs.promises.rm(fullPath, { recursive: true, force: true });
+                        }
+                        catch (rmError) {
+                            // Fallback to rmdir if rm fails
+                            await fs.promises.rmdir(fullPath);
+                        }
+                    }
+                    else {
+                        await fs.promises.unlink(fullPath);
+                    }
                 }
             }
-            // After all contents are deleted, remove the directory itself
-            await fs.promises.rmdir(dirPath);
-        }
-        catch (error) {
-            // If the directory doesn't exist, that's fine
-            if (error.code !== 'ENOENT') {
-                throw error;
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error removing directory contents ${dirPath}:`, error);
+                    throw error;
+                }
             }
-        }
-    }
-    /**
-     * Count the number of JSON files in a directory
-     */
-    async countFilesInDirectory(dirPath) {
+        };
         try {
-            const files = await fs.promises.readdir(dirPath);
-            return files.filter((file) => file.endsWith('.json')).length;
+            // First try the modern approach
+            await fs.promises.rm(this.rootDir, { recursive: true, force: true });
         }
         catch (error) {
-            // If the directory doesn't exist, return 0
-            if (error.code === 'ENOENT') {
-                return 0;
+            console.warn('Modern rm failed, falling back to manual cleanup:', error);
+            // Fallback: manually remove contents then directory
+            try {
+                await removeDirectoryContents(this.rootDir);
+                // Use fs.promises.rm with recursive option instead of rmdir
+                try {
+                    await fs.promises.rm(this.rootDir, { recursive: true, force: true });
+                }
+                catch (rmError) {
+                    // Final fallback to rmdir if rm fails
+                    await fs.promises.rmdir(this.rootDir);
+                }
             }
-            throw error;
-        }
-    }
-    /**
-     * Convert a Map to a plain object for serialization
-     */
-    mapToObject(map, valueTransformer = (v) => v) {
-        const obj = {};
-        for (const [key, value] of map.entries()) {
-            obj[key.toString()] = valueTransformer(value);
-        }
-        return obj;
-    }
-    /**
-     * Get the appropriate directory for a node based on its metadata
-     */
-    async getNodeDirectory(id) {
-        try {
-            // Try to get the metadata for the node
-            const metadata = await this.getMetadata(id);
-            // If metadata exists and has a noun field, use the corresponding directory
-            if (metadata && metadata.noun) {
-                switch (metadata.noun) {
-                    case 'person':
-                        return this.personDir;
-                    case 'place':
-                        return this.placeDir;
-                    case 'thing':
-                        return this.thingDir;
-                    case 'event':
-                        return this.eventDir;
-                    case 'concept':
-                        return this.conceptDir;
-                    case 'content':
-                        return this.contentDir;
-                    default:
-                        return this.defaultDir;
+            catch (fallbackError) {
+                if (fallbackError.code !== 'ENOENT') {
+                    console.error('Manual cleanup also failed:', fallbackError);
+                    throw fallbackError;
                 }
             }
-            // If no metadata or no noun field, use the default directory
-            return this.defaultDir;
-        }
-        catch (error) {
-            // If there's an error getting the metadata, use the default directory
-            return this.defaultDir;
         }
+        this.isInitialized = false; // Reset state
+        await this.init(); // Re-create directories
     }
-    /**
-     * Get information about storage usage and capacity
-     */
     async getStorageStatus() {
-        await this.ensureInitialized();
-        try {
-            // Calculate the total size of all files in the storage directories
-            let totalSize = 0;
-            // Helper function to calculate directory size
-            const calculateDirSize = async (dirPath) => {
-                let size = 0;
-                try {
-                    const files = await fs.promises.readdir(dirPath);
-                    for (const file of files) {
-                        const filePath = path.join(dirPath, file);
-                        const stats = await fs.promises.stat(filePath);
-                        if (stats.isDirectory()) {
-                            size += await calculateDirSize(filePath);
-                        }
-                        else {
-                            size += stats.size;
-                        }
+        if (!this.isInitialized)
+            await this.init();
+        const calculateSize = async (dirPath) => {
+            let size = 0;
+            try {
+                const files = await fs.promises.readdir(dirPath, {
+                    withFileTypes: true
+                });
+                for (const file of files) {
+                    const fullPath = path.join(dirPath, file.name);
+                    if (file.isDirectory()) {
+                        size += await calculateSize(fullPath);
                     }
-                }
-                catch (error) {
-                    console.warn(`Error calculating size for ${dirPath}:`, error);
-                }
-                return size;
-            };
-            // Calculate size for each directory
-            const nodesDirSize = await calculateDirSize(this.nounsDir);
-            const edgesDirSize = await calculateDirSize(this.verbsDir);
-            const metadataDirSize = await calculateDirSize(this.metadataDir);
-            // Calculate sizes of noun type directories
-            const personDirSize = await calculateDirSize(this.personDir);
-            const placeDirSize = await calculateDirSize(this.placeDir);
-            const thingDirSize = await calculateDirSize(this.thingDir);
-            const eventDirSize = await calculateDirSize(this.eventDir);
-            const conceptDirSize = await calculateDirSize(this.conceptDir);
-            const contentDirSize = await calculateDirSize(this.contentDir);
-            const defaultDirSize = await calculateDirSize(this.defaultDir);
-            // Note: The noun type directories are subdirectories of the nodes directory,
-            // so their sizes are already included in nodesDirSize.
-            // We don't need to add them again to avoid double counting.
-            totalSize = nodesDirSize + edgesDirSize + metadataDirSize;
-            // Get filesystem information
-            let quota = null;
-            let details = {
-                nounTypes: {
-                    person: {
-                        size: personDirSize,
-                        count: await this.countFilesInDirectory(this.personDir)
-                    },
-                    place: {
-                        size: placeDirSize,
-                        count: await this.countFilesInDirectory(this.placeDir)
-                    },
-                    thing: {
-                        size: thingDirSize,
-                        count: await this.countFilesInDirectory(this.thingDir)
-                    },
-                    event: {
-                        size: eventDirSize,
-                        count: await this.countFilesInDirectory(this.eventDir)
-                    },
-                    concept: {
-                        size: conceptDirSize,
-                        count: await this.countFilesInDirectory(this.conceptDir)
-                    },
-                    content: {
-                        size: contentDirSize,
-                        count: await this.countFilesInDirectory(this.contentDir)
-                    },
-                    default: {
-                        size: defaultDirSize,
-                        count: await this.countFilesInDirectory(this.defaultDir)
+                    else {
+                        const stats = await fs.promises.stat(fullPath);
+                        size += stats.size;
                     }
                 }
-            };
-            try {
-                // Try to get disk space information
-                const stats = await fs.promises.statfs(this.rootDir);
-                if (stats) {
-                    const availableSpace = stats.bavail * stats.bsize;
-                    const totalSpace = stats.blocks * stats.bsize;
-                    quota = totalSpace;
-                    details = {
-                        availableSpace,
-                        totalSpace,
-                        freePercentage: (availableSpace / totalSpace) * 100
-                    };
-                }
             }
             catch (error) {
-                console.warn('Unable to get filesystem stats:', error);
-                // If statfs is not available, try to use df command on Unix-like systems
-                try {
-                    const { exec } = await Promise.resolve().then(function () { return _child_processShim; });
-                    const util = await Promise.resolve().then(function () { return _utilShim$1; });
-                    const execPromise = util.promisify(exec);
-                    const { stdout } = await execPromise(`df -k "${this.rootDir}"`);
-                    const lines = stdout.trim().split('\n');
-                    if (lines.length > 1) {
-                        const parts = lines[1].split(/\s+/);
-                        if (parts.length >= 4) {
-                            const totalKB = parseInt(parts[1], 10);
-                            const usedKB = parseInt(parts[2], 10);
-                            const availableKB = parseInt(parts[3], 10);
-                            quota = totalKB * 1024;
-                            details = {
-                                availableSpace: availableKB * 1024,
-                                totalSpace: totalKB * 1024,
-                                freePercentage: (availableKB / totalKB) * 100
-                            };
-                        }
-                    }
-                }
-                catch (dfError) {
-                    console.warn('Unable to get disk space using df command:', dfError);
+                if (error.code !== 'ENOENT') {
+                    console.error(`Could not calculate size for ${dirPath}:`, error);
                 }
             }
-            return {
-                type: 'filesystem',
-                used: totalSize,
-                quota,
-                details
-            };
-        }
-        catch (error) {
-            console.error('Failed to get storage status:', error);
-            return {
-                type: 'filesystem',
-                used: 0,
-                quota: null,
-                details: { error: String(error) }
-            };
-        }
+            return size;
+        };
+        const totalSize = await calculateSize(this.rootDir);
+        const nouns = await this.getAllNouns();
+        const verbs = await this.getAllVerbs();
+        return {
+            type: 'FileSystem',
+            used: totalSize,
+            quota: null, // File system quota is not easily available from Node.js
+            details: {
+                rootDir: this.rootDir,
+                nounCount: nouns.length,
+                verbCount: verbs.length
+            }
+        };
     }
 }
 
@@ -14193,28 +14451,21 @@ 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;
 }
-// Apply the TensorFlow.js platform patch if needed
-applyTensorFlowPatch();
-// Export environment information
+// Export environment information with lazy evaluation
 const environment = {
-    isBrowser: typeof window !== 'undefined',
-    isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
-    isServerless: typeof window === 'undefined' &&
-        (typeof process === 'undefined' ||
-            !process.versions ||
-            !process.versions.node)
+    get isBrowser() {
+        return isBrowser$1();
+    },
+    get isNode() {
+        return isNode();
+    },
+    get isServerless() {
+        return !isBrowser$1() && !isNode();
+    }
 };
 // Make environment information available globally
 if (typeof globalThis !== 'undefined') {
@@ -14227,6 +14478,38 @@ console.log(`Brainy running in ${environment.isBrowser
         ? 'Node.js'
         : 'serverless/unknown'} environment`);
 
+// Util shim with TextEncoder/TextDecoder support
+const TextEncoder$1 = globalThis.TextEncoder || (typeof global !== 'undefined' && global.TextEncoder) || class TextEncoder {
+  encode(input) {
+    return new Uint8Array(Buffer.from(input, 'utf8'));
+  }
+};
+
+const TextDecoder$1 = globalThis.TextDecoder || (typeof global !== 'undefined' && global.TextDecoder) || class TextDecoder {
+  decode(input) {
+    return Buffer.from(input).toString('utf8');
+  }
+};
+
+const types = {
+  isFloat32Array: (arr) => arr instanceof Float32Array,
+  isInt32Array: (arr) => arr instanceof Int32Array,
+  isUint8Array: (arr) => arr instanceof Uint8Array,
+  isUint8ClampedArray: (arr) => arr instanceof Uint8ClampedArray
+};
+
+var _utilShim = { TextEncoder: TextEncoder$1, TextDecoder: TextDecoder$1, types };
+const promises = {};
+
+var _utilShim$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	TextDecoder: TextDecoder$1,
+	TextEncoder: TextEncoder$1,
+	default: _utilShim,
+	promises: promises,
+	types: types
+});
+
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -22274,14 +22557,6 @@ var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
 
-var _utilShim = {}; const promises = {};
-
-var _utilShim$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	default: _utilShim,
-	promises: promises
-});
-
 var require$$1 = /*@__PURE__*/getAugmentedNamespace(_utilShim$1);
 
 /**
@@ -22312,7 +22587,7 @@ class PlatformNode {
         this.util = require$$1;
         // According to the spec, the built-in encoder can do only UTF-8 encoding.
         // https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder/TextEncoder
-        this.textEncoder = new TextEncoder();
+        this.textEncoder = new this.util.TextEncoder();
     }
     fetch(path, requestInits) {
         if (env().global.fetch != null) {
@@ -87531,9 +87806,5 @@ var universalSentenceEncoder_esm = /*#__PURE__*/Object.freeze({
 	version: version
 });
 
-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, 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 };
+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, applyTensorFlowPatch, 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=unified.js.map