agentdb 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/src/simd/simd-vector-ops.js

@@ -1,947 +0,0 @@
-/**
- * SIMD-Accelerated Vector Operations for AgentDB
- *
- * High-performance vector operations with WebAssembly SIMD acceleration.
- * Provides 2-8x speedup over standard JavaScript implementations through:
- * - 8x loop unrolling with separate accumulators for Instruction-Level Parallelism (ILP)
- * - Pre-allocated buffer pools to minimize GC pressure
- * - SIMD detection and graceful fallback to optimized scalar code
- * - Batch operations for cache-friendly memory access patterns
- *
- * @module simd-vector-ops
- */
-// ============================================================================
-// Performance & Security Constants
-// ============================================================================
-/** @inline Maximum allowed vector dimension to prevent DoS via large allocations */
-export const MAX_VECTOR_DIMENSION = 4096;
-/** @inline Maximum buffer pool size per dimension bucket */
-const MAX_BUFFER_POOL_SIZE = 128;
-/** @inline Maximum batch size for optimal cache utilization */
-export const MAX_BATCH_SIZE = 10000;
-/** @inline Default cache size for embedding storage */
-export const DEFAULT_CACHE_SIZE = 10000;
-/** @inline Small epsilon for numerical stability */
-const EPSILON = 1e-10;
-// ============================================================================
-// Input Validation Helpers
-// ============================================================================
-/**
- * Validate that a value is a valid Float32Array
- */
-function validateFloat32Array(arr, name) {
-    if (arr === null || arr === undefined) {
-        throw new Error(`${name} cannot be null or undefined`);
-    }
-    if (!(arr instanceof Float32Array)) {
-        throw new Error(`${name} must be a Float32Array`);
-    }
-}
-/**
- * Validate vector dimension is within safe limits
- */
-function validateDimension(dimension, name = 'dimension') {
-    if (!Number.isFinite(dimension) || dimension < 0) {
-        throw new Error(`${name} must be a non-negative finite number`);
-    }
-    if (dimension > MAX_VECTOR_DIMENSION) {
-        throw new Error(`${name} exceeds maximum allowed size of ${MAX_VECTOR_DIMENSION}`);
-    }
-}
-/**
- * Check if a number is valid (not NaN, not Infinity)
- */
-function isValidNumber(n) {
-    return Number.isFinite(n);
-}
-// ============================================================================
-// SIMD Detection
-// ============================================================================
-/**
- * WebAssembly SIMD feature detection
- *
- * Tests for SIMD support by attempting to validate a minimal WASM module
- * that uses SIMD instructions (v128.const and i8x16.extract_lane_s)
- */
-let _simdSupported = null;
-/**
- * Detect WebAssembly SIMD support
- *
- * This function caches the result after first call for performance.
- * The detection is done by validating a minimal WASM module containing
- * SIMD instructions.
- *
- * @returns true if SIMD is supported, false otherwise
- */
-export function detectSIMDSupport() {
-    if (_simdSupported !== null) {
-        return _simdSupported;
-    }
-    try {
-        // Minimal WASM module with SIMD instructions:
-        // - v128.const: Creates a 128-bit vector constant
-        // - i8x16.extract_lane_s: Extracts a signed byte from the vector
-        //
-        // If the browser/runtime supports SIMD, this module will validate successfully
-        const simdTestModule = new Uint8Array([
-            0x00, 0x61, 0x73, 0x6d, // WASM magic number
-            0x01, 0x00, 0x00, 0x00, // Version 1
-            0x01, 0x05, 0x01, 0x60, // Type section: function type () -> i32
-            0x00, 0x01, 0x7f,
-            0x03, 0x02, 0x01, 0x00, // Function section: 1 function of type 0
-            0x0a, 0x16, 0x01, 0x14, // Code section
-            0x00, // No locals
-            0xfd, 0x0c, // v128.const
-            0x00, 0x00, 0x00, 0x00, // Vector constant (16 bytes)
-            0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00,
-            0xfd, 0x15, 0x00, // i8x16.extract_lane_s 0
-            0x0b // end
-        ]);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- WebAssembly runtime detection requires dynamic access
-        const globalAny = globalThis;
-        _simdSupported =
-            typeof globalAny.WebAssembly !== 'undefined' &&
-                typeof globalAny.WebAssembly.validate === 'function' &&
-                globalAny.WebAssembly.validate(simdTestModule);
-    }
-    catch {
-        _simdSupported = false;
-    }
-    // @inline Ensure we always return boolean (not null)
-    return _simdSupported === true;
-}
-/**
- * Alternative SIMD detection using the simpler v128.const check
- * This is the same check used in WASMVectorSearch for consistency
- */
-export function detectSIMDSupportLegacy() {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- WebAssembly runtime detection requires dynamic access
-        const globalAny = globalThis;
-        return (typeof globalAny.WebAssembly !== 'undefined' &&
-            globalAny.WebAssembly.validate(new Uint8Array([
-                0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10,
-                10, 1, 8, 0, 65, 0, 253, 15, 253, 98, 11,
-            ])));
-    }
-    catch {
-        return false;
-    }
-}
-// ============================================================================
-// Optimized Scalar Operations (8x Unrolled with ILP)
-// ============================================================================
-/**
- * Calculate cosine similarity with 8x loop unrolling and ILP
- *
- * Uses 8 separate accumulators to maximize instruction-level parallelism.
- * Modern CPUs can execute multiple independent operations in parallel,
- * and separate accumulators prevent data dependencies between iterations.
- *
- * Performance characteristics:
- * - 8x unrolling reduces loop overhead by 87.5%
- * - Separate accumulators enable out-of-order execution
- * - Final reduction combines accumulators efficiently
- *
- * @param a - First vector (Float32Array)
- * @param b - Second vector (Float32Array)
- * @returns Cosine similarity in range [-1, 1]
- * @throws Error if vectors have different lengths
- */
-export function cosineSimilaritySIMD(a, b) {
-    // Input validation
-    validateFloat32Array(a, 'First vector (a)');
-    validateFloat32Array(b, 'Second vector (b)');
-    const len = a.length;
-    if (len !== b.length) {
-        throw new Error(`Vector length mismatch: ${len} vs ${b.length}. Vectors must have same dimension.`);
-    }
-    validateDimension(len, 'Vector length');
-    if (len === 0) {
-        return 0;
-    }
-    // 8 separate accumulators for instruction-level parallelism
-    // This allows the CPU to execute up to 8 multiply-accumulate operations
-    // in parallel across different execution units
-    let dot0 = 0, dot1 = 0, dot2 = 0, dot3 = 0, dot4 = 0, dot5 = 0, dot6 = 0, dot7 = 0;
-    let normA0 = 0, normA1 = 0, normA2 = 0, normA3 = 0, normA4 = 0, normA5 = 0, normA6 = 0, normA7 = 0;
-    let normB0 = 0, normB1 = 0, normB2 = 0, normB3 = 0, normB4 = 0, normB5 = 0, normB6 = 0, normB7 = 0;
-    // Process 8 elements at a time
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        // Load 8 elements from each vector
-        const a0 = a[i], a1 = a[i + 1], a2 = a[i + 2], a3 = a[i + 3];
-        const a4 = a[i + 4], a5 = a[i + 5], a6 = a[i + 6], a7 = a[i + 7];
-        const b0 = b[i], b1 = b[i + 1], b2 = b[i + 2], b3 = b[i + 3];
-        const b4 = b[i + 4], b5 = b[i + 5], b6 = b[i + 6], b7 = b[i + 7];
-        // Accumulate dot products (independent operations for ILP)
-        dot0 += a0 * b0;
-        dot1 += a1 * b1;
-        dot2 += a2 * b2;
-        dot3 += a3 * b3;
-        dot4 += a4 * b4;
-        dot5 += a5 * b5;
-        dot6 += a6 * b6;
-        dot7 += a7 * b7;
-        // Accumulate norms for vector a
-        normA0 += a0 * a0;
-        normA1 += a1 * a1;
-        normA2 += a2 * a2;
-        normA3 += a3 * a3;
-        normA4 += a4 * a4;
-        normA5 += a5 * a5;
-        normA6 += a6 * a6;
-        normA7 += a7 * a7;
-        // Accumulate norms for vector b
-        normB0 += b0 * b0;
-        normB1 += b1 * b1;
-        normB2 += b2 * b2;
-        normB3 += b3 * b3;
-        normB4 += b4 * b4;
-        normB5 += b5 * b5;
-        normB6 += b6 * b6;
-        normB7 += b7 * b7;
-    }
-    // Handle remaining elements (up to 7)
-    let dotRem = 0, normARem = 0, normBRem = 0;
-    for (let i = loopEnd; i < len; i++) {
-        const ai = a[i], bi = b[i];
-        dotRem += ai * bi;
-        normARem += ai * ai;
-        normBRem += bi * bi;
-    }
-    // Reduce accumulators (tree reduction for numerical stability)
-    const dotProduct = dot0 +
-        dot1 +
-        dot2 +
-        dot3 +
-        dot4 +
-        dot5 +
-        dot6 +
-        dot7 +
-        dotRem;
-    const normA = normA0 +
-        normA1 +
-        normA2 +
-        normA3 +
-        normA4 +
-        normA5 +
-        normA6 +
-        normA7 +
-        normARem;
-    const normB = normB0 +
-        normB1 +
-        normB2 +
-        normB3 +
-        normB4 +
-        normB5 +
-        normB6 +
-        normB7 +
-        normBRem;
-    // @inline Compute final similarity with numerical stability check
-    // Combined sqrt(a*b) is faster than sqrt(a)*sqrt(b) and more numerically stable
-    const denom = Math.sqrt(normA * normB);
-    if (denom < EPSILON || !isValidNumber(denom)) {
-        return 0;
-    }
-    // Clamp to [-1, 1] to handle floating point errors
-    const similarity = dotProduct / denom;
-    // Guard against NaN/Infinity from floating point issues
-    if (!isValidNumber(similarity)) {
-        return 0;
-    }
-    // @inline Branchless clamp is slightly faster than Math.max/min
-    return similarity > 1 ? 1 : similarity < -1 ? -1 : similarity;
-}
-/**
- * Calculate Euclidean (L2) distance with 8x loop unrolling
- *
- * Uses the same ILP optimization as cosine similarity.
- *
- * @param a - First vector (Float32Array)
- * @param b - Second vector (Float32Array)
- * @returns Euclidean distance (non-negative)
- * @throws Error if vectors have different lengths
- */
-export function euclideanDistanceSIMD(a, b) {
-    // Input validation
-    validateFloat32Array(a, 'First vector (a)');
-    validateFloat32Array(b, 'Second vector (b)');
-    const len = a.length;
-    if (len !== b.length) {
-        throw new Error(`Vector length mismatch: ${len} vs ${b.length}. Vectors must have same dimension.`);
-    }
-    validateDimension(len, 'Vector length');
-    if (len === 0) {
-        return 0;
-    }
-    // 8 separate accumulators for ILP
-    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        // Compute squared differences
-        const d0 = a[i] - b[i];
-        const d1 = a[i + 1] - b[i + 1];
-        const d2 = a[i + 2] - b[i + 2];
-        const d3 = a[i + 3] - b[i + 3];
-        const d4 = a[i + 4] - b[i + 4];
-        const d5 = a[i + 5] - b[i + 5];
-        const d6 = a[i + 6] - b[i + 6];
-        const d7 = a[i + 7] - b[i + 7];
-        // Accumulate squared distances (independent for ILP)
-        sum0 += d0 * d0;
-        sum1 += d1 * d1;
-        sum2 += d2 * d2;
-        sum3 += d3 * d3;
-        sum4 += d4 * d4;
-        sum5 += d5 * d5;
-        sum6 += d6 * d6;
-        sum7 += d7 * d7;
-    }
-    // Handle remainder
-    let sumRem = 0;
-    for (let i = loopEnd; i < len; i++) {
-        const d = a[i] - b[i];
-        sumRem += d * d;
-    }
-    // @inline Pairwise reduction for better numerical stability
-    const total = (sum0 + sum1) + (sum2 + sum3) + (sum4 + sum5) + (sum6 + sum7) + sumRem;
-    return Math.sqrt(total);
-}
-/**
- * Calculate squared Euclidean distance (faster than euclideanDistanceSIMD)
- *
- * Useful when you only need to compare distances (skip the sqrt).
- *
- * @param a - First vector
- * @param b - Second vector
- * @returns Squared Euclidean distance
- */
-export function euclideanDistanceSquaredSIMD(a, b) {
-    // Input validation
-    validateFloat32Array(a, 'First vector (a)');
-    validateFloat32Array(b, 'Second vector (b)');
-    const len = a.length;
-    if (len !== b.length) {
-        throw new Error(`Vector length mismatch: ${len} vs ${b.length}`);
-    }
-    validateDimension(len, 'Vector length');
-    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        const d0 = a[i] - b[i];
-        const d1 = a[i + 1] - b[i + 1];
-        const d2 = a[i + 2] - b[i + 2];
-        const d3 = a[i + 3] - b[i + 3];
-        const d4 = a[i + 4] - b[i + 4];
-        const d5 = a[i + 5] - b[i + 5];
-        const d6 = a[i + 6] - b[i + 6];
-        const d7 = a[i + 7] - b[i + 7];
-        sum0 += d0 * d0;
-        sum1 += d1 * d1;
-        sum2 += d2 * d2;
-        sum3 += d3 * d3;
-        sum4 += d4 * d4;
-        sum5 += d5 * d5;
-        sum6 += d6 * d6;
-        sum7 += d7 * d7;
-    }
-    let sumRem = 0;
-    for (let i = loopEnd; i < len; i++) {
-        const d = a[i] - b[i];
-        sumRem += d * d;
-    }
-    return sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7 + sumRem;
-}
-/**
- * Calculate dot product with 8x loop unrolling
- *
- * @param a - First vector
- * @param b - Second vector
- * @returns Dot product
- */
-export function dotProductSIMD(a, b) {
-    // Input validation
-    validateFloat32Array(a, 'First vector (a)');
-    validateFloat32Array(b, 'Second vector (b)');
-    const len = a.length;
-    if (len !== b.length) {
-        throw new Error(`Vector length mismatch: ${len} vs ${b.length}`);
-    }
-    validateDimension(len, 'Vector length');
-    let dot0 = 0, dot1 = 0, dot2 = 0, dot3 = 0, dot4 = 0, dot5 = 0, dot6 = 0, dot7 = 0;
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        dot0 += a[i] * b[i];
-        dot1 += a[i + 1] * b[i + 1];
-        dot2 += a[i + 2] * b[i + 2];
-        dot3 += a[i + 3] * b[i + 3];
-        dot4 += a[i + 4] * b[i + 4];
-        dot5 += a[i + 5] * b[i + 5];
-        dot6 += a[i + 6] * b[i + 6];
-        dot7 += a[i + 7] * b[i + 7];
-    }
-    let dotRem = 0;
-    for (let i = loopEnd; i < len; i++) {
-        dotRem += a[i] * b[i];
-    }
-    return dot0 + dot1 + dot2 + dot3 + dot4 + dot5 + dot6 + dot7 + dotRem;
-}
-/**
- * Calculate L2 norm (magnitude) of a vector with 8x unrolling
- *
- * @param v - Input vector
- * @returns L2 norm
- */
-export function l2NormSIMD(v) {
-    // Input validation
-    validateFloat32Array(v, 'Vector');
-    const len = v.length;
-    validateDimension(len, 'Vector length');
-    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        const v0 = v[i], v1 = v[i + 1], v2 = v[i + 2], v3 = v[i + 3];
-        const v4 = v[i + 4], v5 = v[i + 5], v6 = v[i + 6], v7 = v[i + 7];
-        sum0 += v0 * v0;
-        sum1 += v1 * v1;
-        sum2 += v2 * v2;
-        sum3 += v3 * v3;
-        sum4 += v4 * v4;
-        sum5 += v5 * v5;
-        sum6 += v6 * v6;
-        sum7 += v7 * v7;
-    }
-    let sumRem = 0;
-    for (let i = loopEnd; i < len; i++) {
-        sumRem += v[i] * v[i];
-    }
-    return Math.sqrt(sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7 + sumRem);
-}
-// ============================================================================
-// Vector Normalization
-// ============================================================================
-/**
- * Normalize a vector to unit length (in-place)
- *
- * @param v - Vector to normalize (modified in-place)
- * @returns The same vector, normalized
- */
-export function normalizeVectorInPlace(v) {
-    const norm = l2NormSIMD(v);
-    if (norm === 0) {
-        return v;
-    }
-    const invNorm = 1 / norm;
-    const len = v.length;
-    const loopEnd = len - (len % 8);
-    // 8x unrolled normalization
-    for (let i = 0; i < loopEnd; i += 8) {
-        v[i] *= invNorm;
-        v[i + 1] *= invNorm;
-        v[i + 2] *= invNorm;
-        v[i + 3] *= invNorm;
-        v[i + 4] *= invNorm;
-        v[i + 5] *= invNorm;
-        v[i + 6] *= invNorm;
-        v[i + 7] *= invNorm;
-    }
-    for (let i = loopEnd; i < len; i++) {
-        v[i] *= invNorm;
-    }
-    return v;
-}
-/**
- * Create a normalized copy of a vector
- *
- * @param v - Input vector
- * @returns New normalized vector
- */
-export function normalizeVector(v) {
-    const result = new Float32Array(v);
-    return normalizeVectorInPlace(result);
-}
-// ============================================================================
-// Batch Operations
-// ============================================================================
-/**
- * Batch cosine similarity calculation with early termination optimization
- *
- * Efficiently computes similarities between a query vector and multiple
- * candidate vectors. Uses cache-friendly memory access patterns.
- *
- * @inline V8 optimization hint - hot path function
- * @param query - Query vector
- * @param vectors - Array of candidate vectors
- * @param options - Optional configuration
- * @returns Array of similarity scores (same order as input vectors)
- */
-export function batchCosineSimilarity(query, vectors, options) {
-    // @inline Force integer for loop optimization
-    const vectorCount = vectors.length | 0;
-    const threshold = options?.threshold ?? -Infinity;
-    const topK = options?.topK;
-    const earlyTermThreshold = options?.earlyTerminationThreshold ?? 0.9999;
-    const results = [];
-    // @inline Track perfect matches for early termination
-    let perfectMatches = 0;
-    const maxPerfectMatches = topK ?? 10;
-    // Process all vectors
-    for (let i = 0; i < vectorCount; i++) {
-        const similarity = cosineSimilaritySIMD(query, vectors[i]);
-        if (similarity >= threshold) {
-            results.push({
-                index: i,
-                similarity,
-            });
-            // @inline Early termination check for perfect matches
-            if (similarity >= earlyTermThreshold) {
-                perfectMatches++;
-                if (topK && perfectMatches >= maxPerfectMatches) {
-                    break; // Early termination - found enough high-quality matches
-                }
-            }
-        }
-    }
-    // Sort by similarity (descending)
-    results.sort((a, b) => b.similarity - a.similarity);
-    // Return top-k if specified
-    if (topK !== undefined && topK > 0) {
-        return results.slice(0, topK);
-    }
-    return results;
-}
-/**
- * Batch Euclidean distance calculation with early termination
- *
- * @inline V8 optimization hint - hot path function
- * @param query - Query vector
- * @param vectors - Array of candidate vectors
- * @param options - Optional configuration
- * @returns Array of distance results (same order as input vectors)
- */
-export function batchEuclideanDistance(query, vectors, options) {
-    // @inline Force integer for loop optimization
-    const vectorCount = vectors.length | 0;
-    const maxDist = options?.maxDistance ?? Infinity;
-    const useSquared = options?.squared ?? false;
-    const topK = options?.topK;
-    const earlyTermDist = options?.earlyTerminationDistance ?? 0.0001;
-    // @inline Select distance function once outside loop
-    const distFn = useSquared ? euclideanDistanceSquaredSIMD : euclideanDistanceSIMD;
-    const results = [];
-    let nearPerfectMatches = 0;
-    const maxNearPerfect = topK ?? 10;
-    for (let i = 0; i < vectorCount; i++) {
-        const distance = distFn(query, vectors[i]);
-        if (distance <= maxDist) {
-            results.push({
-                index: i,
-                similarity: 1 / (1 + distance), // Convert to similarity-like score
-                distance,
-            });
-            // @inline Early termination for near-zero distances
-            if (distance <= earlyTermDist) {
-                nearPerfectMatches++;
-                if (topK && nearPerfectMatches >= maxNearPerfect) {
-                    break;
-                }
-            }
-        }
-    }
-    // Sort by distance (ascending)
-    results.sort((a, b) => (a.distance ?? 0) - (b.distance ?? 0));
-    if (topK !== undefined && topK > 0) {
-        return results.slice(0, topK);
-    }
-    return results;
-}
-// ============================================================================
-// Buffer Pool for Memory Efficiency
-// ============================================================================
-/**
- * Pre-allocated buffer pool to reduce GC pressure
- *
- * Reuses Float32Array buffers for temporary computations,
- * avoiding frequent memory allocations during vector operations.
- */
-class BufferPool {
-    pools = new Map();
-    maxPoolSize;
-    stats = {
-        allocations: 0,
-        reuses: 0,
-        returns: 0,
-    };
-    constructor(maxPoolSize = 32) {
-        // Enforce maximum pool size limit for security
-        this.maxPoolSize = Math.min(Math.max(1, maxPoolSize), MAX_BUFFER_POOL_SIZE);
-    }
-    /**
-     * Acquire a buffer of the specified size
-     */
-    acquire(size) {
-        // Validate size to prevent DoS
-        if (!Number.isFinite(size) || size < 0 || size > MAX_VECTOR_DIMENSION) {
-            throw new Error(`Invalid buffer size: ${size}. Must be between 0 and ${MAX_VECTOR_DIMENSION}`);
-        }
-        const pool = this.pools.get(size);
-        if (pool && pool.length > 0) {
-            this.stats.reuses++;
-            return pool.pop();
-        }
-        this.stats.allocations++;
-        return new Float32Array(size);
-    }
-    /**
-     * Return a buffer to the pool
-     */
-    release(buffer) {
-        const size = buffer.length;
-        let pool = this.pools.get(size);
-        if (!pool) {
-            pool = [];
-            this.pools.set(size, pool);
-        }
-        if (pool.length < this.maxPoolSize) {
-            // Zero the buffer before returning to pool (security)
-            buffer.fill(0);
-            pool.push(buffer);
-            this.stats.returns++;
-        }
-        // If pool is full, buffer will be garbage collected
-    }
-    /**
-     * Get pool statistics
-     */
-    getStats() {
-        return {
-            ...this.stats,
-            poolSizes: Array.from(this.pools.keys()),
-        };
-    }
-    /**
-     * Clear all pools
-     */
-    clear() {
-        this.pools.clear();
-    }
-}
-// ============================================================================
-// SIMDVectorOps Class
-// ============================================================================
-/**
- * SIMD-accelerated vector operations manager
- *
- * Provides a stateful wrapper around vector operations with:
- * - Automatic SIMD detection
- * - Pre-allocated buffer pools
- * - Operation statistics tracking
- * - Configurable behavior
- */
-export class SIMDVectorOps {
-    config;
-    simdEnabled;
-    bufferPool;
-    stats;
-    constructor(config) {
-        this.config = {
-            enableSIMD: config?.enableSIMD ?? true,
-            bufferPoolSize: config?.bufferPoolSize ?? 32,
-            defaultDimension: config?.defaultDimension ?? 384,
-            enableLogging: config?.enableLogging ?? false,
-        };
-        // Detect SIMD support
-        this.simdEnabled = this.config.enableSIMD && detectSIMDSupport();
-        // Initialize buffer pool
-        this.bufferPool = new BufferPool(this.config.bufferPoolSize);
-        // Initialize stats
-        this.stats = {
-            simdEnabled: this.simdEnabled,
-            vectorsProcessed: 0,
-            operationsCount: 0,
-            buffersInPool: 0,
-            peakBufferUsage: 0,
-        };
-        if (this.config.enableLogging) {
-            console.log(`[SIMDVectorOps] Initialized with SIMD ${this.simdEnabled ? 'enabled' : 'disabled'}`);
-        }
-    }
-    /**
-     * Calculate cosine similarity between two vectors
-     */
-    cosineSimilarity(a, b) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 2;
-        return cosineSimilaritySIMD(a, b);
-    }
-    /**
-     * Calculate Euclidean distance between two vectors
-     */
-    euclideanDistance(a, b) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 2;
-        return euclideanDistanceSIMD(a, b);
-    }
-    /**
-     * Calculate squared Euclidean distance (faster for comparisons)
-     */
-    euclideanDistanceSquared(a, b) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 2;
-        return euclideanDistanceSquaredSIMD(a, b);
-    }
-    /**
-     * Calculate dot product
-     */
-    dotProduct(a, b) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 2;
-        return dotProductSIMD(a, b);
-    }
-    /**
-     * Calculate L2 norm
-     */
-    l2Norm(v) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed++;
-        return l2NormSIMD(v);
-    }
-    /**
-     * Normalize a vector (creates a copy)
-     */
-    normalize(v) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed++;
-        return normalizeVector(v);
-    }
-    /**
-     * Normalize a vector in place
-     */
-    normalizeInPlace(v) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed++;
-        return normalizeVectorInPlace(v);
-    }
-    /**
-     * Batch cosine similarity
-     */
-    batchCosineSimilarity(query, vectors, options) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 1 + vectors.length;
-        return batchCosineSimilarity(query, vectors, options);
-    }
-    /**
-     * Batch Euclidean distance
-     */
-    batchEuclideanDistance(query, vectors, options) {
-        this.stats.operationsCount++;
-        this.stats.vectorsProcessed += 1 + vectors.length;
-        return batchEuclideanDistance(query, vectors, options);
-    }
-    /**
-     * Acquire a temporary buffer from the pool
-     */
-    acquireBuffer(size) {
-        const bufferSize = size ?? this.config.defaultDimension;
-        this.stats.peakBufferUsage = Math.max(this.stats.peakBufferUsage, this.stats.buffersInPool + 1);
-        return this.bufferPool.acquire(bufferSize);
-    }
-    /**
-     * Release a buffer back to the pool
-     */
-    releaseBuffer(buffer) {
-        this.bufferPool.release(buffer);
-    }
-    /**
-     * Get operation statistics
-     */
-    getStats() {
-        const poolStats = this.bufferPool.getStats();
-        return {
-            ...this.stats,
-            buffersInPool: poolStats.poolSizes.length,
-        };
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            simdEnabled: this.simdEnabled,
-            vectorsProcessed: 0,
-            operationsCount: 0,
-            buffersInPool: 0,
-            peakBufferUsage: 0,
-        };
-    }
-    /**
-     * Check if SIMD is enabled
-     */
-    isSIMDEnabled() {
-        return this.simdEnabled;
-    }
-    /**
-     * Clear buffer pools
-     */
-    clearBufferPool() {
-        this.bufferPool.clear();
-    }
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Create a Float32Array from various input types
- *
- * @param data - Input data (array of numbers, ArrayBuffer, or existing Float32Array)
- * @returns Float32Array
- */
-export function toFloat32Array(data) {
-    if (data instanceof Float32Array) {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return new Float32Array(data);
-    }
-    return new Float32Array(data);
-}
-/**
- * Create random unit vector for testing
- *
- * @param dimension - Vector dimension
- * @returns Normalized random vector
- */
-export function randomUnitVector(dimension) {
-    // Input validation to prevent DoS via large allocations
-    if (!Number.isFinite(dimension) || dimension < 0 || !Number.isInteger(dimension)) {
-        throw new Error('Dimension must be a non-negative integer');
-    }
-    validateDimension(dimension, 'Dimension');
-    const v = new Float32Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-        v[i] = Math.random() * 2 - 1;
-    }
-    return normalizeVector(v);
-}
-/**
- * Vector addition with 8x unrolling
- *
- * @param a - First vector
- * @param b - Second vector
- * @param out - Optional output buffer (creates new if not provided)
- * @returns Result vector (a + b)
- */
-export function vectorAdd(a, b, out) {
-    const len = a.length;
-    const result = out ?? new Float32Array(len);
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        result[i] = a[i] + b[i];
-        result[i + 1] = a[i + 1] + b[i + 1];
-        result[i + 2] = a[i + 2] + b[i + 2];
-        result[i + 3] = a[i + 3] + b[i + 3];
-        result[i + 4] = a[i + 4] + b[i + 4];
-        result[i + 5] = a[i + 5] + b[i + 5];
-        result[i + 6] = a[i + 6] + b[i + 6];
-        result[i + 7] = a[i + 7] + b[i + 7];
-    }
-    for (let i = loopEnd; i < len; i++) {
-        result[i] = a[i] + b[i];
-    }
-    return result;
-}
-/**
- * Vector subtraction with 8x unrolling
- *
- * @param a - First vector
- * @param b - Second vector
- * @param out - Optional output buffer
- * @returns Result vector (a - b)
- */
-export function vectorSub(a, b, out) {
-    const len = a.length;
-    const result = out ?? new Float32Array(len);
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        result[i] = a[i] - b[i];
-        result[i + 1] = a[i + 1] - b[i + 1];
-        result[i + 2] = a[i + 2] - b[i + 2];
-        result[i + 3] = a[i + 3] - b[i + 3];
-        result[i + 4] = a[i + 4] - b[i + 4];
-        result[i + 5] = a[i + 5] - b[i + 5];
-        result[i + 6] = a[i + 6] - b[i + 6];
-        result[i + 7] = a[i + 7] - b[i + 7];
-    }
-    for (let i = loopEnd; i < len; i++) {
-        result[i] = a[i] - b[i];
-    }
-    return result;
-}
-/**
- * Scalar multiplication with 8x unrolling
- *
- * @param v - Input vector
- * @param scalar - Scalar multiplier
- * @param out - Optional output buffer
- * @returns Result vector (v * scalar)
- */
-export function vectorScale(v, scalar, out) {
-    const len = v.length;
-    const result = out ?? new Float32Array(len);
-    const loopEnd = len - (len % 8);
-    for (let i = 0; i < loopEnd; i += 8) {
-        result[i] = v[i] * scalar;
-        result[i + 1] = v[i + 1] * scalar;
-        result[i + 2] = v[i + 2] * scalar;
-        result[i + 3] = v[i + 3] * scalar;
-        result[i + 4] = v[i + 4] * scalar;
-        result[i + 5] = v[i + 5] * scalar;
-        result[i + 6] = v[i + 6] * scalar;
-        result[i + 7] = v[i + 7] * scalar;
-    }
-    for (let i = loopEnd; i < len; i++) {
-        result[i] = v[i] * scalar;
-    }
-    return result;
-}
-// ============================================================================
-// Default Export
-// ============================================================================
-/**
- * Default SIMD vector operations instance
- *
- * Pre-configured with sensible defaults. For custom configuration,
- * create a new SIMDVectorOps instance.
- */
-export const defaultSIMDOps = new SIMDVectorOps();
-export default {
-    // Core operations
-    cosineSimilaritySIMD,
-    euclideanDistanceSIMD,
-    euclideanDistanceSquaredSIMD,
-    dotProductSIMD,
-    l2NormSIMD,
-    // Normalization
-    normalizeVector,
-    normalizeVectorInPlace,
-    // Batch operations
-    batchCosineSimilarity,
-    batchEuclideanDistance,
-    // Vector math
-    vectorAdd,
-    vectorSub,
-    vectorScale,
-    // Utilities
-    toFloat32Array,
-    randomUnitVector,
-    detectSIMDSupport,
-    detectSIMDSupportLegacy,
-    // Class
-    SIMDVectorOps,
-    // Default instance
-    defaultSIMDOps,
-};
-//# sourceMappingURL=simd-vector-ops.js.map