@soulcraft/brainy 0.11.0 → 0.12.0

package/dist/brainy.js

@@ -2397,86 +2397,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
- * using the native TextEncoder/TextDecoder APIs.
+ * 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() {
+    // 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);
+}
+/**
+ * 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.4.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());
+}
+
 /**
- * Get a text encoder that works in the current environment
- * @returns A TextEncoder instance
+ * Flag to track if the patch has been applied
  */
+let patchApplied = false;
 /**
- * Apply the TensorFlow.js platform patch if needed
- * This function patches the global object to provide a PlatformNode class
- * that uses native TextEncoder/TextDecoder
+ * Monkeypatch TensorFlow.js's PlatformNode class to fix TextEncoder/TextDecoder issues
+ * CRITICAL: This runs immediately at the top level when this module is imported
  */
-function applyTensorFlowPatch() {
+if (typeof globalThis !== 'undefined' && isNode()) {
     try {
-        // Define a custom Platform class that works in both Node.js and browser environments
-        class Platform {
-            constructor() {
-                // Create a util object with necessary methods and constructors
-                this.util = {
-                    // Use native TextEncoder and TextDecoder
+        // 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 {
+            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
+                    };
+                }
+            };
+            // 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
+                    TextDecoder: TextDecoder,
+                    types: {
+                        isFloat32Array: (arr) => arr instanceof Float32Array,
+                        isInt32Array: (arr) => arr instanceof Int32Array,
+                        isUint8Array: (arr) => arr instanceof Uint8Array,
+                        isUint8ClampedArray: (arr) => arr instanceof Uint8ClampedArray
+                    }
                 };
-                // Initialize 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));
-            }
-        }
-        // Get the global object in a way that works in both Node.js and browser
-        const globalObj = typeof global !== 'undefined'
-            ? global
-            : typeof window !== 'undefined'
-                ? window
-                : typeof self !== 'undefined'
-                    ? self
-                    : {};
-        // Only apply in Node.js environment
-        if (typeof process !== 'undefined' &&
-            process.versions &&
-            process.versions.node) {
-            // Assign the Platform class to the global object as PlatformNode for Node.js
-            ;
-            globalObj.PlatformNode = Platform;
-            globalObj.platformNode = new Platform();
-        }
-        else if (typeof window !== 'undefined' || typeof self !== 'undefined') {
-            // In browser environments, we might need to provide similar functionality
-            // but we'll use a different name to avoid conflicts
-            ;
-            globalObj.PlatformBrowser = Platform;
-            globalObj.platformBrowser = new Platform();
+            }
+            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
+            }
+        }
+        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) {
+            // Ignore if util module is not available
         }
+        patchApplied = true;
     }
     catch (error) {
-        console.warn('Failed to apply TensorFlow.js platform patch:', 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
+});
 
 /**
- * This file is imported for its side effects to patch the environment
+ * 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.
- */
-// Apply the TensorFlow.js platform patch if needed
+ *
+ * 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
@@ -2636,12 +2950,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]);
@@ -2753,76 +3086,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.4.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
@@ -3301,80 +3564,127 @@ 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;
-        }
-        // Add polyfill for isFloat32Array in Node.js 24.4.0
-        // This fixes the "Cannot read properties of undefined (reading 'isFloat32Array')" error
-        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;
-                global.platformNode = new PlatformNode();
-            }
-            catch (error) {
-                console.warn('Failed to define global PlatformNode class:', error);
-            }
+    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 (!global.util) {
-                global.util = {};
+            if (!globalObj.util) {
+                globalObj.util = {};
             }
             // Add isFloat32Array method if it doesn't exist
-            if (!global.util.isFloat32Array) {
-                global.util.isFloat32Array = (obj) => {
+            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 (!global.util.isTypedArray) {
-                global.util.isTypedArray = (obj) => {
+            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.NODE_ENV === 'test' ||
+            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;
+                }
+            }
+        }
+        // This should never be reached, but just in case
+        throw lastError || new Error('Unknown error during model loading');
     }
     /**
      * Initialize the embedding model
@@ -3393,43 +3703,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
@@ -3437,14 +3791,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}`);
         }
     }
@@ -3491,7 +3845,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}`);
         }
     }
@@ -3540,7 +3894,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}`);
         }
     }
@@ -3556,7 +3910,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();
@@ -3644,11 +3998,36 @@ 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.NODE_ENV === 'test' ||
+        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);
     };
@@ -3666,13 +4045,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}`);
         }
     };
@@ -3704,7 +4090,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}`);
     }
 };
@@ -8081,6 +8467,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
      */
@@ -8094,6 +8500,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
@@ -8197,6 +8609,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,
@@ -8280,6 +8699,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
@@ -8306,7 +8729,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()) {
@@ -8324,6 +8752,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
@@ -8475,7 +8915,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
@@ -8569,6 +9011,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, {
@@ -8617,6 +9062,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) {
@@ -10173,6 +10621,7 @@ class FileSystemStorage {
         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));
     }
     /**
@@ -10198,7 +10647,60 @@ class FileSystemStorage {
     async clear() {
         if (!this.isInitialized)
             await this.init();
-        await fs.promises.rm(this.rootDir, { recursive: true, force: true });
+        // 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);
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error removing directory contents ${dirPath}:`, error);
+                    throw error;
+                }
+            }
+        };
+        try {
+            // First try the modern approach
+            await fs.promises.rm(this.rootDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            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);
+                }
+            }
+            catch (fallbackError) {
+                if (fallbackError.code !== 'ENOENT') {
+                    console.error('Manual cleanup also failed:', fallbackError);
+                    throw fallbackError;
+                }
+            }
+        }
         this.isInitialized = false; // Reset state
         await this.init(); // Re-create directories
     }
@@ -13957,19 +14459,17 @@ class BrainyMCPService {
 if (typeof window !== 'undefined' && typeof globalThis.Buffer === 'undefined') {
   globalThis.Buffer = buffer$1.Buffer;
 }
-/**
- * Unified entry point for Brainy
- * This file exports everything from index.ts
- * Environment detection is handled here and made available to all components
- */
-// 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') {
@@ -13982,6 +14482,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.
@@ -22029,14 +22561,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);
 
 /**
@@ -87286,5 +87810,5 @@ var universalSentenceEncoder_esm = /*#__PURE__*/Object.freeze({
 	version: version
 });
 
-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=brainy.js.map