moflo 4.8.16 → 4.8.19

package/src/@claude-flow/memory/dist/hnsw-index.js

@@ -1,781 +0,0 @@
-/**
- * V3 HNSW Vector Index
- *
- * High-performance Hierarchical Navigable Small World (HNSW) index for
- * 150x-12,500x faster vector similarity search compared to brute force.
- *
- * OPTIMIZATIONS:
- * - BinaryMinHeap/BinaryMaxHeap for O(log n) operations (vs O(n log n) Array.sort)
- * - Pre-normalized vectors for O(1) cosine similarity (no sqrt needed)
- * - Bounded max-heap for efficient top-k tracking
- *
- * @module v3/memory/hnsw-index
- */
-import { EventEmitter } from 'node:events';
-/**
- * Binary Min Heap for O(log n) priority queue operations
- * Used for candidate selection in HNSW search
- */
-class BinaryMinHeap {
-    heap = [];
-    get size() {
-        return this.heap.length;
-    }
-    insert(item, priority) {
-        this.heap.push({ item, priority });
-        this.bubbleUp(this.heap.length - 1);
-    }
-    extractMin() {
-        if (this.heap.length === 0)
-            return undefined;
-        const min = this.heap[0].item;
-        const last = this.heap.pop();
-        if (this.heap.length > 0) {
-            this.heap[0] = last;
-            this.bubbleDown(0);
-        }
-        return min;
-    }
-    peek() {
-        return this.heap[0]?.item;
-    }
-    peekPriority() {
-        return this.heap[0]?.priority;
-    }
-    isEmpty() {
-        return this.heap.length === 0;
-    }
-    toArray() {
-        return this.heap
-            .slice()
-            .sort((a, b) => a.priority - b.priority)
-            .map((entry) => entry.item);
-    }
-    bubbleUp(index) {
-        while (index > 0) {
-            const parent = Math.floor((index - 1) / 2);
-            if (this.heap[parent].priority <= this.heap[index].priority)
-                break;
-            [this.heap[parent], this.heap[index]] = [this.heap[index], this.heap[parent]];
-            index = parent;
-        }
-    }
-    bubbleDown(index) {
-        const length = this.heap.length;
-        while (true) {
-            let smallest = index;
-            const left = 2 * index + 1;
-            const right = 2 * index + 2;
-            if (left < length && this.heap[left].priority < this.heap[smallest].priority) {
-                smallest = left;
-            }
-            if (right < length && this.heap[right].priority < this.heap[smallest].priority) {
-                smallest = right;
-            }
-            if (smallest === index)
-                break;
-            [this.heap[smallest], this.heap[index]] = [this.heap[index], this.heap[smallest]];
-            index = smallest;
-        }
-    }
-}
-/**
- * Binary Max Heap for bounded top-k tracking
- * Keeps track of k smallest elements by evicting largest when full
- */
-class BinaryMaxHeap {
-    heap = [];
-    maxSize;
-    constructor(maxSize = Infinity) {
-        this.maxSize = maxSize;
-    }
-    get size() {
-        return this.heap.length;
-    }
-    insert(item, priority) {
-        // If at capacity and new item is worse than worst, reject
-        if (this.heap.length >= this.maxSize && priority >= this.heap[0]?.priority) {
-            return false;
-        }
-        if (this.heap.length >= this.maxSize) {
-            // Replace max element
-            this.heap[0] = { item, priority };
-            this.bubbleDown(0);
-        }
-        else {
-            this.heap.push({ item, priority });
-            this.bubbleUp(this.heap.length - 1);
-        }
-        return true;
-    }
-    peekMax() {
-        return this.heap[0]?.item;
-    }
-    peekMaxPriority() {
-        return this.heap[0]?.priority ?? Infinity;
-    }
-    extractMax() {
-        if (this.heap.length === 0)
-            return undefined;
-        const max = this.heap[0].item;
-        const last = this.heap.pop();
-        if (this.heap.length > 0) {
-            this.heap[0] = last;
-            this.bubbleDown(0);
-        }
-        return max;
-    }
-    isEmpty() {
-        return this.heap.length === 0;
-    }
-    toSortedArray() {
-        return this.heap.slice().sort((a, b) => a.priority - b.priority);
-    }
-    bubbleUp(index) {
-        while (index > 0) {
-            const parent = Math.floor((index - 1) / 2);
-            if (this.heap[parent].priority >= this.heap[index].priority)
-                break;
-            [this.heap[parent], this.heap[index]] = [this.heap[index], this.heap[parent]];
-            index = parent;
-        }
-    }
-    bubbleDown(index) {
-        const length = this.heap.length;
-        while (true) {
-            let largest = index;
-            const left = 2 * index + 1;
-            const right = 2 * index + 2;
-            if (left < length && this.heap[left].priority > this.heap[largest].priority) {
-                largest = left;
-            }
-            if (right < length && this.heap[right].priority > this.heap[largest].priority) {
-                largest = right;
-            }
-            if (largest === index)
-                break;
-            [this.heap[largest], this.heap[index]] = [this.heap[index], this.heap[largest]];
-            index = largest;
-        }
-    }
-}
-/**
- * HNSW Index implementation for ultra-fast vector similarity search
- *
- * Performance characteristics:
- * - Search: O(log n) approximate nearest neighbor
- * - Insert: O(log n) amortized
- * - Memory: O(n * M * L) where M is max connections, L is layers
- */
-export class HNSWIndex extends EventEmitter {
-    config;
-    nodes = new Map();
-    entryPoint = null;
-    maxLevel = 0;
-    levelMult;
-    // Performance tracking
-    stats = {
-        searchCount: 0,
-        totalSearchTime: 0,
-        insertCount: 0,
-        totalInsertTime: 0,
-        buildStartTime: 0,
-    };
-    // Quantization support
-    quantizer = null;
-    constructor(config = {}) {
-        super();
-        this.config = this.mergeConfig(config);
-        this.levelMult = 1 / Math.log(this.config.M);
-        if (this.config.quantization) {
-            this.quantizer = new Quantizer(this.config.quantization, this.config.dimensions);
-        }
-    }
-    /**
-     * Add a vector to the index
-     */
-    async addPoint(id, vector) {
-        const startTime = performance.now();
-        if (vector.length !== this.config.dimensions) {
-            throw new Error(`Vector dimension mismatch: expected ${this.config.dimensions}, got ${vector.length}`);
-        }
-        if (this.nodes.size >= this.config.maxElements) {
-            throw new Error('Index is full, cannot add more elements');
-        }
-        // Quantize if enabled
-        const storedVector = this.quantizer
-            ? this.quantizer.encode(vector)
-            : vector;
-        // Pre-normalize vector for O(1) cosine similarity
-        const normalizedVector = this.config.metric === 'cosine'
-            ? this.normalizeVector(storedVector)
-            : null;
-        // Generate random level for new node
-        const level = this.getRandomLevel();
-        const node = {
-            id,
-            vector: storedVector,
-            normalizedVector,
-            connections: new Map(),
-            level,
-        };
-        // Initialize connection sets for each layer
-        for (let l = 0; l <= level; l++) {
-            node.connections.set(l, new Set());
-        }
-        if (this.entryPoint === null) {
-            // First node
-            this.entryPoint = id;
-            this.maxLevel = level;
-            this.nodes.set(id, node);
-        }
-        else {
-            // Insert new node into the graph
-            await this.insertNode(node);
-        }
-        const duration = performance.now() - startTime;
-        this.stats.insertCount++;
-        this.stats.totalInsertTime += duration;
-        this.emit('point:added', { id, level, duration });
-    }
-    /**
-     * Search for k nearest neighbors
-     */
-    async search(query, k, ef) {
-        const startTime = performance.now();
-        if (query.length !== this.config.dimensions) {
-            throw new Error(`Query dimension mismatch: expected ${this.config.dimensions}, got ${query.length}`);
-        }
-        if (this.entryPoint === null) {
-            return [];
-        }
-        const searchEf = ef || Math.max(k, this.config.efConstruction);
-        // Quantize query if needed
-        const queryVector = this.quantizer
-            ? this.quantizer.encode(query)
-            : query;
-        // Pre-normalize query for O(1) cosine similarity
-        const normalizedQuery = this.config.metric === 'cosine'
-            ? this.normalizeVector(queryVector)
-            : null;
-        // Start from entry point and search down the layers
-        let currentNode = this.entryPoint;
-        let currentDist = this.distanceOptimized(queryVector, normalizedQuery, this.nodes.get(currentNode));
-        // Search through layers from top to 1
-        for (let level = this.maxLevel; level > 0; level--) {
-            const layerResult = this.searchLayerOptimized(queryVector, normalizedQuery, currentNode, 1, level);
-            currentNode = layerResult[0]?.id || currentNode;
-            currentDist = this.distanceOptimized(queryVector, normalizedQuery, this.nodes.get(currentNode));
-        }
-        // Search layer 0 with ef candidates using heap-based search
-        const candidates = this.searchLayerOptimized(queryVector, normalizedQuery, currentNode, searchEf, 0);
-        // Return top k results (already sorted by heap)
-        const results = candidates.slice(0, k);
-        const duration = performance.now() - startTime;
-        this.stats.searchCount++;
-        this.stats.totalSearchTime += duration;
-        return results;
-    }
-    /**
-     * Search with filters applied post-retrieval
-     */
-    async searchWithFilters(query, k, filter, ef) {
-        // Over-fetch to account for filtered results
-        const overFetchFactor = 3;
-        const candidates = await this.search(query, k * overFetchFactor, ef);
-        return candidates
-            .filter((c) => filter(c.id))
-            .slice(0, k);
-    }
-    /**
-     * Remove a point from the index
-     */
-    async removePoint(id) {
-        const node = this.nodes.get(id);
-        if (!node) {
-            return false;
-        }
-        // Remove all connections to this node
-        for (let level = 0; level <= node.level; level++) {
-            const connections = node.connections.get(level);
-            if (connections) {
-                for (const connectedId of connections) {
-                    const connectedNode = this.nodes.get(connectedId);
-                    if (connectedNode) {
-                        connectedNode.connections.get(level)?.delete(id);
-                    }
-                }
-            }
-        }
-        this.nodes.delete(id);
-        // Update entry point if needed
-        if (this.entryPoint === id) {
-            if (this.nodes.size === 0) {
-                this.entryPoint = null;
-                this.maxLevel = 0;
-            }
-            else {
-                // Find new entry point with highest level
-                let newEntry = null;
-                let newMaxLevel = 0;
-                for (const [nodeId, n] of this.nodes) {
-                    if (newEntry === null || n.level > newMaxLevel) {
-                        newMaxLevel = n.level;
-                        newEntry = nodeId;
-                    }
-                }
-                this.entryPoint = newEntry;
-                this.maxLevel = newMaxLevel;
-            }
-        }
-        this.emit('point:removed', { id });
-        return true;
-    }
-    /**
-     * Rebuild the index from scratch
-     */
-    async rebuild(entries) {
-        this.stats.buildStartTime = performance.now();
-        this.nodes.clear();
-        this.entryPoint = null;
-        this.maxLevel = 0;
-        for (const entry of entries) {
-            await this.addPoint(entry.id, entry.vector);
-        }
-        const buildTime = performance.now() - this.stats.buildStartTime;
-        this.emit('index:rebuilt', {
-            vectorCount: this.nodes.size,
-            buildTime,
-        });
-    }
-    /**
-     * Get index statistics
-     */
-    getStats() {
-        const vectorCount = this.nodes.size;
-        const avgSearchTime = this.stats.searchCount > 0
-            ? this.stats.totalSearchTime / this.stats.searchCount
-            : 0;
-        // Estimate memory usage
-        const bytesPerVector = this.config.dimensions * 4; // Float32 = 4 bytes
-        const connectionOverhead = this.config.M * 8 * (this.maxLevel + 1); // Approximate
-        const memoryUsage = vectorCount * (bytesPerVector + connectionOverhead);
-        return {
-            vectorCount,
-            memoryUsage,
-            avgSearchTime,
-            buildTime: performance.now() - this.stats.buildStartTime,
-            compressionRatio: this.quantizer?.getCompressionRatio() || 1.0,
-        };
-    }
-    /**
-     * Clear the index
-     */
-    clear() {
-        this.nodes.clear();
-        this.entryPoint = null;
-        this.maxLevel = 0;
-        this.stats = {
-            searchCount: 0,
-            totalSearchTime: 0,
-            insertCount: 0,
-            totalInsertTime: 0,
-            buildStartTime: 0,
-        };
-    }
-    /**
-     * Check if an ID exists in the index
-     */
-    has(id) {
-        return this.nodes.has(id);
-    }
-    /**
-     * Get the number of vectors in the index
-     */
-    get size() {
-        return this.nodes.size;
-    }
-    // ===== Private Methods =====
-    mergeConfig(config) {
-        return {
-            dimensions: config.dimensions || 1536, // OpenAI embedding size
-            M: config.M || 16,
-            efConstruction: config.efConstruction || 200,
-            maxElements: config.maxElements || 1000000,
-            metric: config.metric || 'cosine',
-            quantization: config.quantization,
-        };
-    }
-    getRandomLevel() {
-        let level = 0;
-        while (Math.random() < 0.5 && level < 16) {
-            level++;
-        }
-        return level;
-    }
-    async insertNode(node) {
-        const query = node.vector;
-        const normalizedQuery = node.normalizedVector;
-        let currentNode = this.entryPoint;
-        let currentDist = this.distanceOptimized(query, normalizedQuery, this.nodes.get(currentNode));
-        // Find entry point for the node's level
-        for (let level = this.maxLevel; level > node.level; level--) {
-            const result = this.searchLayerOptimized(query, normalizedQuery, currentNode, 1, level);
-            if (result.length > 0 && result[0].distance < currentDist) {
-                currentNode = result[0].id;
-                currentDist = result[0].distance;
-            }
-        }
-        // Insert at each level from node.level down to 0
-        for (let level = Math.min(node.level, this.maxLevel); level >= 0; level--) {
-            const neighbors = this.searchLayerOptimized(query, normalizedQuery, currentNode, this.config.efConstruction, level);
-            // Select M best neighbors
-            const selectedNeighbors = this.selectNeighbors(node.id, query, neighbors, this.config.M);
-            // Add connections
-            for (const neighbor of selectedNeighbors) {
-                node.connections.get(level).add(neighbor.id);
-                this.nodes.get(neighbor.id)?.connections.get(level)?.add(node.id);
-                // Prune connections if over limit
-                const neighborNode = this.nodes.get(neighbor.id);
-                if (neighborNode) {
-                    const neighborConns = neighborNode.connections.get(level);
-                    if (neighborConns.size > this.config.M * 2) {
-                        this.pruneConnections(neighborNode, level, this.config.M);
-                    }
-                }
-            }
-            if (neighbors.length > 0) {
-                currentNode = neighbors[0].id;
-            }
-        }
-        this.nodes.set(node.id, node);
-        // Update max level if needed
-        if (node.level > this.maxLevel) {
-            this.maxLevel = node.level;
-            this.entryPoint = node.id;
-        }
-    }
-    async searchLayer(query, entryPoint, ef, level) {
-        const visited = new Set([entryPoint]);
-        const candidates = [];
-        const results = [];
-        const entryDist = this.distance(query, this.nodes.get(entryPoint).vector);
-        candidates.push({ id: entryPoint, distance: entryDist });
-        results.push({ id: entryPoint, distance: entryDist });
-        while (candidates.length > 0) {
-            // Get closest candidate
-            candidates.sort((a, b) => a.distance - b.distance);
-            const current = candidates.shift();
-            // Check termination condition
-            const worstResult = results.length > 0
-                ? Math.max(...results.map((r) => r.distance))
-                : Infinity;
-            if (current.distance > worstResult && results.length >= ef) {
-                break;
-            }
-            // Explore neighbors
-            const node = this.nodes.get(current.id);
-            if (!node)
-                continue;
-            const connections = node.connections.get(level);
-            if (!connections)
-                continue;
-            for (const neighborId of connections) {
-                if (visited.has(neighborId))
-                    continue;
-                visited.add(neighborId);
-                const neighborNode = this.nodes.get(neighborId);
-                if (!neighborNode)
-                    continue;
-                const distance = this.distance(query, neighborNode.vector);
-                if (results.length < ef || distance < worstResult) {
-                    candidates.push({ id: neighborId, distance });
-                    results.push({ id: neighborId, distance });
-                    // Keep results bounded
-                    if (results.length > ef) {
-                        results.sort((a, b) => a.distance - b.distance);
-                        results.pop();
-                    }
-                }
-            }
-        }
-        return results.sort((a, b) => a.distance - b.distance);
-    }
-    /**
-     * OPTIMIZED searchLayer using heap-based priority queues
-     * Performance: O(log n) per operation vs O(n log n) for Array.sort()
-     * Expected speedup: 3-5x for large result sets
-     */
-    searchLayerOptimized(query, normalizedQuery, entryPoint, ef, level) {
-        const visited = new Set([entryPoint]);
-        // Min-heap for candidates (closest first for expansion)
-        const candidates = new BinaryMinHeap();
-        // Max-heap for results (bounded size, tracks worst distance efficiently)
-        const results = new BinaryMaxHeap(ef);
-        const entryNode = this.nodes.get(entryPoint);
-        const entryDist = this.distanceOptimized(query, normalizedQuery, entryNode);
-        candidates.insert(entryPoint, entryDist);
-        results.insert(entryPoint, entryDist);
-        while (!candidates.isEmpty()) {
-            // Get closest candidate - O(log n)
-            const currentDist = candidates.peekPriority();
-            const currentId = candidates.extractMin();
-            // Check termination: if closest candidate is worse than worst result, stop
-            const worstResultDist = results.peekMaxPriority();
-            if (currentDist > worstResultDist && results.size >= ef) {
-                break;
-            }
-            // Explore neighbors
-            const node = this.nodes.get(currentId);
-            if (!node)
-                continue;
-            const connections = node.connections.get(level);
-            if (!connections)
-                continue;
-            for (const neighborId of connections) {
-                if (visited.has(neighborId))
-                    continue;
-                visited.add(neighborId);
-                const neighborNode = this.nodes.get(neighborId);
-                if (!neighborNode)
-                    continue;
-                const distance = this.distanceOptimized(query, normalizedQuery, neighborNode);
-                // Only add if within threshold or results not full
-                if (results.size < ef || distance < worstResultDist) {
-                    candidates.insert(neighborId, distance);
-                    // Max-heap handles size bounding automatically - O(log n)
-                    results.insert(neighborId, distance);
-                }
-            }
-        }
-        // Return sorted results
-        return results.toSortedArray().map(({ item, priority }) => ({
-            id: item,
-            distance: priority,
-        }));
-    }
-    selectNeighbors(nodeId, query, candidates, M) {
-        // Simple selection: take M closest
-        return candidates
-            .filter((c) => c.id !== nodeId)
-            .sort((a, b) => a.distance - b.distance)
-            .slice(0, M);
-    }
-    pruneConnections(node, level, maxConnections) {
-        const connections = node.connections.get(level);
-        if (!connections || connections.size <= maxConnections)
-            return;
-        // Calculate distances to all connections
-        const distances = [];
-        for (const connId of connections) {
-            const connNode = this.nodes.get(connId);
-            if (connNode) {
-                distances.push({
-                    id: connId,
-                    distance: this.distance(node.vector, connNode.vector),
-                });
-            }
-        }
-        // Keep only the closest ones
-        distances.sort((a, b) => a.distance - b.distance);
-        const toKeep = new Set(distances.slice(0, maxConnections).map((d) => d.id));
-        // Remove excess connections
-        for (const connId of connections) {
-            if (!toKeep.has(connId)) {
-                connections.delete(connId);
-                this.nodes.get(connId)?.connections.get(level)?.delete(node.id);
-            }
-        }
-    }
-    distance(a, b) {
-        switch (this.config.metric) {
-            case 'cosine':
-                return this.cosineDistance(a, b);
-            case 'euclidean':
-                return this.euclideanDistance(a, b);
-            case 'dot':
-                return this.dotProductDistance(a, b);
-            case 'manhattan':
-                return this.manhattanDistance(a, b);
-            default:
-                return this.cosineDistance(a, b);
-        }
-    }
-    cosineDistance(a, b) {
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-        return 1 - similarity; // Convert to distance
-    }
-    /**
-     * OPTIMIZED: Cosine distance using pre-normalized vectors
-     * Only requires dot product (no sqrt operations)
-     * Performance: O(n) with ~2x speedup over standard cosine
-     */
-    cosineDistanceNormalized(a, b) {
-        let dotProduct = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-        }
-        // For normalized vectors: cosine_similarity = dot_product
-        // Return distance (1 - similarity)
-        return 1 - dotProduct;
-    }
-    /**
-     * Normalize a vector to unit length for O(1) cosine similarity
-     */
-    normalizeVector(vector) {
-        let norm = 0;
-        for (let i = 0; i < vector.length; i++) {
-            norm += vector[i] * vector[i];
-        }
-        norm = Math.sqrt(norm);
-        if (norm === 0) {
-            return vector; // Return as-is if zero vector
-        }
-        const normalized = new Float32Array(vector.length);
-        for (let i = 0; i < vector.length; i++) {
-            normalized[i] = vector[i] / norm;
-        }
-        return normalized;
-    }
-    /**
-     * OPTIMIZED distance calculation that uses pre-normalized vectors when available
-     */
-    distanceOptimized(query, normalizedQuery, node) {
-        // Use optimized path for cosine with pre-normalized vectors
-        if (this.config.metric === 'cosine' &&
-            normalizedQuery !== null &&
-            node.normalizedVector !== null) {
-            return this.cosineDistanceNormalized(normalizedQuery, node.normalizedVector);
-        }
-        // Fall back to standard distance calculation
-        return this.distance(query, node.vector);
-    }
-    euclideanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return Math.sqrt(sum);
-    }
-    dotProductDistance(a, b) {
-        let dotProduct = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-        }
-        // Negative because higher dot product = more similar
-        return -dotProduct;
-    }
-    manhattanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            sum += Math.abs(a[i] - b[i]);
-        }
-        return sum;
-    }
-}
-/**
- * Quantizer for vector compression
- */
-class Quantizer {
-    config;
-    dimensions;
-    constructor(config, dimensions) {
-        this.config = config;
-        this.dimensions = dimensions;
-    }
-    /**
-     * Encode a vector using quantization
-     */
-    encode(vector) {
-        switch (this.config.type) {
-            case 'binary':
-                return this.binaryQuantize(vector);
-            case 'scalar':
-                return this.scalarQuantize(vector);
-            case 'product':
-                return this.productQuantize(vector);
-            default:
-                return vector;
-        }
-    }
-    /**
-     * Get compression ratio
-     */
-    getCompressionRatio() {
-        switch (this.config.type) {
-            case 'binary':
-                return 32; // 32x compression (32 bits -> 1 bit per dimension)
-            case 'scalar':
-                return 32 / (this.config.bits || 8);
-            case 'product':
-                return this.config.subquantizers || 8;
-            default:
-                return 1;
-        }
-    }
-    binaryQuantize(vector) {
-        // Simple binary quantization: > 0 becomes 1, <= 0 becomes 0
-        // Stored in packed format in a smaller Float32Array
-        const packedLength = Math.ceil(vector.length / 32);
-        const packed = new Float32Array(packedLength);
-        for (let i = 0; i < vector.length; i++) {
-            const packedIndex = Math.floor(i / 32);
-            const bitPosition = i % 32;
-            if (vector[i] > 0) {
-                packed[packedIndex] = (packed[packedIndex] || 0) | (1 << bitPosition);
-            }
-        }
-        return packed;
-    }
-    scalarQuantize(vector) {
-        // Find min/max for normalization
-        let min = Infinity;
-        let max = -Infinity;
-        for (let i = 0; i < vector.length; i++) {
-            if (vector[i] < min)
-                min = vector[i];
-            if (vector[i] > max)
-                max = vector[i];
-        }
-        const range = max - min || 1;
-        const bits = this.config.bits || 8;
-        const levels = Math.pow(2, bits);
-        // Quantize each value
-        const quantized = new Float32Array(vector.length + 2); // +2 for min/range
-        quantized[0] = min;
-        quantized[1] = range;
-        for (let i = 0; i < vector.length; i++) {
-            const normalized = (vector[i] - min) / range;
-            quantized[i + 2] = Math.round(normalized * (levels - 1));
-        }
-        return quantized;
-    }
-    productQuantize(vector) {
-        // Simplified product quantization
-        // In production, would use trained codebooks
-        const subquantizers = this.config.subquantizers || 8;
-        const subvectorSize = Math.ceil(vector.length / subquantizers);
-        const quantized = new Float32Array(subquantizers);
-        for (let i = 0; i < subquantizers; i++) {
-            let sum = 0;
-            const start = i * subvectorSize;
-            const end = Math.min(start + subvectorSize, vector.length);
-            for (let j = start; j < end; j++) {
-                sum += vector[j];
-            }
-            quantized[i] = sum / (end - start);
-        }
-        return quantized;
-    }
-}
-export default HNSWIndex;
-//# sourceMappingURL=hnsw-index.js.map