verso-db 0.5.0 → 0.6.0

package/dist/HNSWIndex.js

@@ -2,7 +2,7 @@
 import { dotProductFast, l2SquaredFast, normalizeInPlace } from './backends/JsDistanceBackend.js';
 import { BinaryHeap } from './BinaryHeap.js';
 import { MaxBinaryHeap } from './MaxBinaryHeap.js';
-import { ScalarQuantizer, l2SquaredInt8, cosineDistanceInt8, dotProductInt8 } from './quantization/ScalarQuantizer.js';
+import { ScalarQuantizer } from './quantization/ScalarQuantizer.js';
 import { deltaEncodeNeighbors, deltaDecodeNeighbors } from './encoding/DeltaEncoder.js';
 import { VectorDBError } from './errors.js';
 export class HNSWIndex {
@@ -73,8 +73,6 @@ export class HNSWIndex {
     random;
     // Quantization support for 3-4x faster search with Int8
     scalarQuantizer = null;
-    // OPTIMIZATION: Use array instead of Map for int8 vectors too
-    int8Vectors = [];
     quantizationEnabled = false;
     // OPTIMIZATION: Contiguous Int8 storage for cache-friendly batch distance calculations
     // Layout: [v0_d0...v0_dn, v1_d0...v1_dn, ...], offset: nodeId * dim
@@ -831,8 +829,7 @@ export class HNSWIndex {
         // Keep quantized representation in sync for indexes that were
         // quantized before new inserts.
         if (this.quantizationEnabled && this.scalarQuantizer) {
-            this.int8Vectors[id] = this.scalarQuantizer.quantize(floatVector);
-            // Also update contiguous Int8 storage
+            // Update contiguous Int8 storage
             if (this.flatInt8Vectors) {
                 this.scalarQuantizer.quantizeInto(floatVector, this.flatInt8Vectors, id * this.dimension);
             }
@@ -1120,21 +1117,36 @@ export class HNSWIndex {
         const dim = this.dimension;
         const sampleSize = Math.min(Math.ceil(Math.sqrt(n)), 2000);
         const seedCount = Math.min(Math.ceil(Math.sqrt(n)), 500);
-        // Random sample indices
+        // Random sample indices. Bound the random-draw attempts so a degenerate RNG
+        // (e.g. a constant function injected via the constructor) can't spin forever;
+        // any shortfall is filled deterministically by scanning unused indices.
         const sampleIndices = [];
         const usedIndices = new Set();
-        while (sampleIndices.length < sampleSize) {
+        const maxAttempts = sampleSize * 20;
+        let attempts = 0;
+        while (sampleIndices.length < sampleSize && attempts < maxAttempts) {
+            attempts++;
             const idx = Math.floor(this.randomFloat() * n);
             if (!usedIndices.has(idx)) {
                 usedIndices.add(idx);
                 sampleIndices.push(idx);
             }
         }
+        if (sampleIndices.length < sampleSize) {
+            for (let i = 0; i < n && sampleIndices.length < sampleSize; i++) {
+                if (!usedIndices.has(i)) {
+                    usedIndices.add(i);
+                    sampleIndices.push(i);
+                }
+            }
+        }
         // Farthest-point sampling on the sample
         // Start with a random point from the sample
         const seedSamplePositions = [0]; // positions within sampleIndices
         const minDists = new Float64Array(sampleSize);
         minDists.fill(Infinity);
+        // Seed 0 is already selected — mark it so the greedy loop doesn't re-pick it.
+        minDists[0] = -1;
         // Compute initial distances from first seed
         const firstVec = points[sampleIndices[0]].vector;
         for (let i = 1; i < sampleSize; i++) {
@@ -1359,7 +1371,6 @@ export class HNSWIndex {
                     this.setNode(newNode);
                     // Keep quantized representation in sync
                     if (this.quantizationEnabled && this.scalarQuantizer) {
-                        this.int8Vectors[id] = this.scalarQuantizer.quantize(vector);
                         if (this.flatInt8Vectors) {
                             this.scalarQuantizer.quantizeInto(vector, this.flatInt8Vectors, id * this.dimension);
                         }
@@ -1530,7 +1541,7 @@ export class HNSWIndex {
     }
     // Format version constants
     static MAGIC = 0x484E5357; // "HNSW" in ASCII (big-endian: 0x48='H', 0x4E='N', 0x53='S', 0x57='W')
-    static FORMAT_VERSION = 3; // v3: vector offset index for lazy loading
+    static FORMAT_VERSION = 4; // v4: appended trailer with quantization params + calibration stats (graph/vector sections byte-identical to v3)
     static HEADER_SIZE = 40; // 4 (magic) + 4 (version) + 28 (existing header) + 4 (vectorDataOffset)
     static ensureReadable(bufferLength, offset, bytes, context) {
         if (offset + bytes > bufferLength) {
@@ -1538,6 +1549,33 @@ export class HNSWIndex {
             throw new VectorDBError(`Corrupt HNSW data: truncated ${context} (need ${bytes} bytes, only ${available} available)`, 'CORRUPT_INDEX');
         }
     }
+    /**
+     * Read a dimension-length float32 vector from a serialized buffer at the given
+     * absolute byte offset. Callers must have already validated that
+     * [absoluteOffset, absoluteOffset + dimension*4) fits within the buffer.
+     *
+     * Fast path: when the offset is 4-byte aligned we construct a Float32Array view
+     * directly over the buffer and bulk-copy. Otherwise we fall back to a DataView
+     * loop. Either way every component is validated for finiteness in a single pass.
+     */
+    static readVectorBytes(buffer, view, absoluteOffset, dimension, nodeIndex) {
+        HNSWIndex.ensureReadable(buffer.byteLength, absoluteOffset, dimension * 4, `node ${nodeIndex} vector payload`);
+        const vector = new Float32Array(dimension);
+        if (absoluteOffset % 4 === 0) {
+            vector.set(new Float32Array(buffer, absoluteOffset, dimension));
+        }
+        else {
+            for (let j = 0; j < dimension; j++) {
+                vector[j] = view.getFloat32(absoluteOffset + j * 4, true);
+            }
+        }
+        for (let j = 0; j < dimension; j++) {
+            if (!Number.isFinite(vector[j])) {
+                throw new VectorDBError(`Corrupt HNSW data: node ${nodeIndex} vector component ${j} is non-finite (${vector[j]})`, 'CORRUPT_INDEX');
+            }
+        }
+        return vector;
+    }
     static wrapDeserializeError(error) {
         if (error instanceof VectorDBError) {
             return error;
@@ -1675,16 +1713,31 @@ export class HNSWIndex {
                 totalNeighbors += neighbors?.length ?? 0;
             }
         }
-        // Pre-allocate with capacity for ALL nodes (not just current ones).
-        // During parallel build, serializeGraphToSharedBuffers is called after the seed phase
-        // (e.g. 500 nodes), but the full index may grow to flatVectorsCapacity nodes.
-        // Each node has up to M0 layer-0 neighbors + M upper-layer neighbors.
-        // The append-only write pattern creates dead space when nodes are rewritten,
-        // so we use 3x the estimated maximum to accommodate waste.
-        const nodeCapacity = Math.max(this.nodeCount, this.flatVectorsCapacity);
-        const estimatedMaxNeighbors = nodeCapacity * (this.M0 + this.M);
-        const neighborCapacity = Math.max(Math.ceil(totalNeighbors * 3), totalNeighbors + 10000, estimatedMaxNeighbors * 3);
-        const indexSize = nodeCapacity * maxLayerSlots * 2;
+        // Capacity sizing depends on whether this is a parallel build or a read-only pool.
+        //
+        // Parallel build (constructionMode === true): the graph grows after init and the
+        // append-only update pattern (updateSharedGraphNodes) rewrites nodes, creating dead
+        // space. We pre-allocate for ALL nodes (up to flatVectorsCapacity) at 3x the estimated
+        // maximum so incremental updates have room. addPointsBulkParallel sets constructionMode
+        // = true BEFORE pool.init() (which triggers this serialization), so this path is taken
+        // during parallel build.
+        //
+        // Read-only pool (constructionMode === false): the graph is finished and immutable from
+        // the workers' perspective. There are no incremental rewrites, so we size tightly to the
+        // current node count. This avoids allocating ~864MB SABs for a finished 1M-node index.
+        let neighborCapacity;
+        let indexSize;
+        if (this.constructionMode) {
+            const nodeCapacity = Math.max(this.nodeCount, this.flatVectorsCapacity);
+            const estimatedMaxNeighbors = nodeCapacity * (this.M0 + this.M);
+            neighborCapacity = Math.max(Math.ceil(totalNeighbors * 3), totalNeighbors + 10000, estimatedMaxNeighbors * 3);
+            indexSize = nodeCapacity * maxLayerSlots * 2;
+        }
+        else {
+            neighborCapacity = Math.max(totalNeighbors + 1024, 1024);
+            // Index area must still cover every node's layer slots.
+            indexSize = this.nodeCount * maxLayerSlots * 2;
+        }
         const graphIndex = new Uint32Array(new SharedArrayBuffer(indexSize * 4));
         const graphNeighborData = new Uint32Array(new SharedArrayBuffer(neighborCapacity * 4));
         // Shared metadata: [nodeCount, entryPointId, maxLevel]
@@ -1742,11 +1795,14 @@ export class HNSWIndex {
                     this.clearSharedGraph();
                     return;
                 }
-                this.sharedGraphIndex[base] = writeOffset;
-                this.sharedGraphIndex[base + 1] = neighbors.length;
+                // Write the neighbor payload FIRST, then publish the index entry (offset +
+                // count). A concurrent worker that reads the index entry will then always
+                // see fully-written neighbor data, never not-yet-written zeros.
                 for (let n = 0; n < neighbors.length; n++) {
                     this.sharedGraphNeighborData[writeOffset + n] = neighbors[n];
                 }
+                this.sharedGraphIndex[base] = writeOffset;
+                this.sharedGraphIndex[base + 1] = neighbors.length;
                 writeOffset += neighbors.length;
             }
         }
@@ -1832,6 +1888,20 @@ export class HNSWIndex {
         if (this.nodeCount === 0 || this.entryPointId === -1) {
             return new Map();
         }
+        // Reorder rebuilds all flat storage from node.vector, which holds zeros for
+        // unloaded lazy vectors. Materialize every vector first, then drop lazy state
+        // so the rebuilt structures and remapped IDs are self-consistent.
+        if (this.lazyLoadEnabled) {
+            for (let i = 0; i < this.nodeCount; i++) {
+                if (this.nodes[i]) {
+                    this.loadVector(i);
+                }
+            }
+            this.lazyLoadEnabled = false;
+            this.vectorBuffer = null;
+            this.vectorOffsets.clear();
+            this.vectorsLoaded.clear();
+        }
         const dim = this.dimension;
         const oldToNew = new Map();
         const visited = new Set();
@@ -1840,8 +1910,9 @@ export class HNSWIndex {
         let newId = 0;
         queue.push(this.entryPointId);
         visited.add(this.entryPointId);
-        while (queue.length > 0) {
-            const oldId = queue.shift();
+        let head = 0;
+        while (head < queue.length) {
+            const oldId = queue[head++];
             oldToNew.set(oldId, newId++);
             const node = this.nodes[oldId];
             if (!node)
@@ -1868,10 +1939,8 @@ export class HNSWIndex {
         const newNodes = new Array(newId);
         const newFlatVectors = HNSWIndex.allocateFloat32(Math.max(newId, this.flatVectorsCapacity) * dim, this.useSharedMemory);
         let newFlatInt8Vectors = null;
-        let newInt8Vectors = [];
         if (this.quantizationEnabled && this.flatInt8Vectors) {
             newFlatInt8Vectors = HNSWIndex.allocateInt8(Math.max(newId, this.flatInt8VectorsCapacity) * dim, this.useSharedMemory);
-            newInt8Vectors = new Array(newId);
         }
         // Copy nodes with remapped IDs and neighbor lists
         for (const [oldId, nid] of oldToNew) {
@@ -1899,9 +1968,6 @@ export class HNSWIndex {
                     newFlatInt8Vectors[newOffset + d] = this.flatInt8Vectors[oldOffset + d];
                 }
             }
-            if (this.int8Vectors[oldId]) {
-                newInt8Vectors[nid] = this.int8Vectors[oldId];
-            }
             // Create new node with vector from flat storage
             const vec = new Float32Array(dim);
             vec.set(newFlatVectors.subarray(newOffset, newOffset + dim));
@@ -1922,7 +1988,6 @@ export class HNSWIndex {
             this.flatInt8Vectors = newFlatInt8Vectors;
             this.flatInt8VectorsCapacity = Math.max(newId, this.flatInt8VectorsCapacity);
         }
-        this.int8Vectors = newInt8Vectors;
         this.nodeCount = newId;
         this.nextAutoId = newId;
         // Reset visited array for new ID space
@@ -1975,7 +2040,22 @@ export class HNSWIndex {
         graphSize += nodeCount * 4; // vector offset table
         const vectorDataOffset = graphSize;
         const vectorDataSize = nodeCount * this.dimension * 4;
-        const totalSize = graphSize + vectorDataSize;
+        // v4 trailer (appended after the vector section). Graph + vector sections are
+        // byte-identical to v3; v4 always writes at least the flags uint32 so a trailer
+        // is guaranteed to exist. We do NOT store int8 vector bytes — they are rebuilt
+        // by re-quantizing float32 vectors on load.
+        const writeQuantParams = this.quantizationEnabled && this.scalarQuantizer !== null;
+        const writeCalibration = this.calibrationStats !== null;
+        let quantBlob = null;
+        let trailerSize = 4; // flags uint32
+        if (writeQuantParams) {
+            quantBlob = this.scalarQuantizer.serialize();
+            trailerSize += 4 + quantBlob.byteLength; // length prefix + blob
+        }
+        if (writeCalibration) {
+            trailerSize += 16; // meanEntryDist (f64) + stdEntryDist (f64)
+        }
+        const totalSize = graphSize + vectorDataSize + trailerSize;
         const buffer = new ArrayBuffer(totalSize);
         const view = new DataView(buffer);
         const uint8Array = new Uint8Array(buffer);
@@ -2034,14 +2114,50 @@ export class HNSWIndex {
             view.setUint32(offset, i * this.dimension * 4, true); // Relative offset
             offset += 4;
         }
-        // Write vectors at end (for lazy loading capability)
+        // Write vectors at end (for lazy loading capability).
+        // When this index is itself lazy-loaded, unloaded nodes still hold a
+        // placeholder zero vector in node.vector, so read their bytes directly from
+        // the backing buffer instead of materializing every vector into memory.
+        const sourceView = this.lazyLoadEnabled && this.vectorBuffer ? new DataView(this.vectorBuffer) : null;
         for (let i = 0; i < nodesArray.length; i++) {
             const node = nodesArray[i];
-            for (let j = 0; j < this.dimension; j++) {
-                view.setFloat32(offset, node.vector[j], true);
-                offset += 4;
+            if (this.lazyLoadEnabled && !this.vectorsLoaded.has(node.id)) {
+                const srcOffset = this.vectorOffsets.get(node.id);
+                if (sourceView === null || srcOffset === undefined) {
+                    throw new VectorDBError(`Corrupt HNSW data: lazy node ${node.id} has no backing vector buffer to serialize`, 'CORRUPT_INDEX');
+                }
+                for (let j = 0; j < this.dimension; j++) {
+                    view.setFloat32(offset, sourceView.getFloat32(srcOffset + j * 4, true), true);
+                    offset += 4;
+                }
+            }
+            else {
+                for (let j = 0; j < this.dimension; j++) {
+                    view.setFloat32(offset, node.vector[j], true);
+                    offset += 4;
+                }
             }
         }
+        // Write v4 trailer. bit 0 = quantization params present, bit 1 = calibration stats present.
+        let flags = 0;
+        if (writeQuantParams)
+            flags |= 1;
+        if (writeCalibration)
+            flags |= 2;
+        view.setUint32(offset, flags, true);
+        offset += 4;
+        if (writeQuantParams && quantBlob !== null) {
+            view.setUint32(offset, quantBlob.byteLength, true);
+            offset += 4;
+            uint8Array.set(new Uint8Array(quantBlob), offset);
+            offset += quantBlob.byteLength;
+        }
+        if (writeCalibration && this.calibrationStats !== null) {
+            view.setFloat64(offset, this.calibrationStats.meanEntryDist, true);
+            offset += 8;
+            view.setFloat64(offset, this.calibrationStats.stdEntryDist, true);
+            offset += 8;
+        }
         return buffer;
     }
     /**
@@ -2079,6 +2195,9 @@ export class HNSWIndex {
                 ensureReadable(4, context);
                 const value = view.getFloat32(offset, true);
                 offset += 4;
+                if (!Number.isFinite(value)) {
+                    throw new VectorDBError(`Corrupt HNSW data: ${context} is non-finite (${value})`, 'CORRUPT_INDEX');
+                }
                 return value;
             };
             // Check for magic header (new format v1+)
@@ -2265,15 +2384,14 @@ export class HNSWIndex {
                     }
                 }
                 else {
-                    // Eager loading: load all vectors now
+                    // Eager loading: load all vectors now.
+                    // The offset table validation above already guarantees each vector's
+                    // full [offset, offset + dimension*4) range fits within the buffer, so
+                    // we bulk-copy instead of bounds-checking each component.
                     for (let i = 0; i < nodeCount; i++) {
                         const { id, level } = nodeMetadata[i];
                         const vectorOffset = index.vectorOffsets.get(id);
-                        const vector = new Float32Array(dimension);
-                        for (let j = 0; j < dimension; j++) {
-                            HNSWIndex.ensureReadable(buffer.byteLength, vectorOffset + j * 4, 4, `node ${i} vector component ${j}`);
-                            vector[j] = view.getFloat32(vectorOffset + j * 4, true);
-                        }
+                        const vector = HNSWIndex.readVectorBytes(buffer, view, vectorOffset, dimension, i);
                         const node = { id, level, vector, neighbors: nodeNeighbors[i] };
                         index.setNode(node);
                         index.vectorsLoaded.add(id);
@@ -2368,6 +2486,56 @@ export class HNSWIndex {
                     }
                 }
             }
+            // v4 trailer: appended after the vector section. v0-v3 buffers have no
+            // trailer, so this is skipped entirely for them (their parsing above is
+            // byte-for-byte unchanged). The vector section runs from vectorDataOffset
+            // for nodeCount * dimension * 4 bytes; the trailer starts immediately after.
+            if (formatVersion >= 4) {
+                let trailerOffset = vectorDataOffset + nodeCount * dimension * 4;
+                const readTrailerUint32 = (context) => {
+                    HNSWIndex.ensureReadable(buffer.byteLength, trailerOffset, 4, context);
+                    const value = view.getUint32(trailerOffset, true);
+                    trailerOffset += 4;
+                    return value;
+                };
+                const readTrailerFloat64 = (context) => {
+                    HNSWIndex.ensureReadable(buffer.byteLength, trailerOffset, 8, context);
+                    const value = view.getFloat64(trailerOffset, true);
+                    trailerOffset += 8;
+                    return value;
+                };
+                const flags = readTrailerUint32('v4 trailer flags');
+                const hasQuant = (flags & 1) !== 0;
+                const hasCalibration = (flags & 2) !== 0;
+                if (hasQuant) {
+                    const quantBlobLength = readTrailerUint32('v4 quant blob length');
+                    HNSWIndex.ensureReadable(buffer.byteLength, trailerOffset, quantBlobLength, 'v4 quant blob');
+                    const blobStart = trailerOffset;
+                    const blobEnd = trailerOffset + quantBlobLength;
+                    trailerOffset = blobEnd;
+                    if (lazyLoad) {
+                        // Lazy loading skips restoring quantization: the float32 vectors are
+                        // not materialized, so we cannot re-quantize them into flatInt8Vectors.
+                        // Leave quantizationEnabled = false; quantized blob bytes are consumed
+                        // (offset advanced) but the quantizer is not reconstructed. Searches
+                        // fall back to the float32 path, which lazy-loads vectors on demand.
+                    }
+                    else {
+                        // slice() returns a fresh ArrayBuffer with byteOffset 0, which
+                        // ScalarQuantizer.deserialize() expects.
+                        const quantBlob = buffer.slice(blobStart, blobEnd);
+                        const quantizer = ScalarQuantizer.deserialize(quantBlob);
+                        index.installQuantizer(quantizer);
+                    }
+                }
+                if (hasCalibration) {
+                    const meanEntryDist = readTrailerFloat64('v4 calibration meanEntryDist');
+                    const stdEntryDist = readTrailerFloat64('v4 calibration stdEntryDist');
+                    // Calibration stats work for lazy loads too (no vectors needed).
+                    index.calibrationStats = { meanEntryDist, stdEntryDist };
+                }
+                // Bytes after the trailer (if any) are ignored.
+            }
             if (nodeCount > 0 && observedMaxLevel !== maxLevel) {
                 throw new VectorDBError(`Corrupt HNSW data: maxLevel ${maxLevel} does not match highest node level ${observedMaxLevel}`, 'CORRUPT_INDEX');
             }
@@ -2403,10 +2571,7 @@ export class HNSWIndex {
         if (vectorOffset === undefined)
             return null;
         const view = new DataView(this.vectorBuffer);
-        const vector = new Float32Array(this.dimension);
-        for (let j = 0; j < this.dimension; j++) {
-            vector[j] = view.getFloat32(vectorOffset + j * 4, true);
-        }
+        const vector = HNSWIndex.readVectorBytes(this.vectorBuffer, view, vectorOffset, this.dimension, nodeId);
         // Update node with loaded vector
         node.vector = vector;
         this.vectorsLoaded.add(nodeId);
@@ -2482,10 +2647,27 @@ export class HNSWIndex {
         // Reset entry point and level so reuse after destroy doesn't crash
         this.entryPointId = -1;
         this.maxLevel = -1;
-        // Clear quantization state
-        this.int8Vectors = [];
+        // Clear quantization state, including the contiguous int8 buffer and the
+        // reusable query buffer (these can be capacity*dimension bytes).
         this.quantizationEnabled = false;
         this.scalarQuantizer = null;
+        this.flatInt8Vectors = null;
+        this.flatInt8VectorsCapacity = 0;
+        this.queryInt8Buffer = null;
+        // Release shared-graph SABs (sharedGraphIndex/NeighborData/Metadata).
+        this.clearSharedGraph();
+        // Shrink visited tracking back to a small array.
+        this.visitedArraySize = 1024;
+        this.visitedArray = new Uint16Array(this.visitedArraySize);
+        this.visitedGeneration = 1;
+        // Replace grown search heaps with small-capacity instances.
+        this.heapCapacity = 500;
+        this.candidatesHeap = new BinaryHeap(this.heapCapacity);
+        this.resultsHeap = new MaxBinaryHeap(this.heapCapacity);
+        this.selectionHeap = new BinaryHeap(Math.max(this.M * 2, 1));
+        // Drop calibration stats and construction-time neighbor sets.
+        this.calibrationStats = null;
+        this.neighborSets.clear();
         // Clear lazy-load state
         this.lazyLoadEnabled = false;
         this.vectorOffsets.clear();
@@ -2549,6 +2731,15 @@ export class HNSWIndex {
         }
         return result;
     }
+    /**
+     * Get a single vector by its numeric node id, or null if absent.
+     * Returns a defensive copy so callers cannot mutate internal storage.
+     * Keyed consistently with getAllVectors() and Collection's numeric ids.
+     */
+    getVectorById(id) {
+        const vector = this.getNodeVector(id);
+        return vector ? new Float32Array(vector) : null;
+    }
     // ============================================
     // Quantized Search (Int8 with automatic rescoring)
     // ============================================
@@ -2587,12 +2778,24 @@ export class HNSWIndex {
             vectors.push(vector);
         }
         // Initialize and train scalar (int8) quantizer
-        this.scalarQuantizer = new ScalarQuantizer(this.dimension);
-        this.scalarQuantizer.train(vectors);
-        // Quantize all existing vectors - use array instead of Map
-        this.int8Vectors = new Array(this.nodeCount);
-        // Also build contiguous Int8 storage for cache-friendly batch distance calculations
+        const quantizer = new ScalarQuantizer(this.dimension);
+        quantizer.train(vectors);
+        // Build contiguous Int8 storage + reusable query buffer and enable quantization.
+        this.installQuantizer(quantizer);
+    }
+    /**
+     * Build quantized state from an already-trained ScalarQuantizer.
+     *
+     * Shared by enableQuantization() (which trains the quantizer first) and
+     * deserialize() (which restores the quantizer from a serialized blob). Mirrors
+     * enableQuantization() exactly EXCEPT training: allocates the contiguous
+     * flatInt8Vectors buffer, quantizes every live node's float vector into it,
+     * allocates the reusable queryInt8Buffer, and flips quantizationEnabled on.
+     */
+    installQuantizer(quantizer) {
         const dim = this.dimension;
+        this.scalarQuantizer = quantizer;
+        // Build contiguous Int8 storage for cache-friendly batch distance calculations
         this.flatInt8VectorsCapacity = Math.max(this.nodeCount, this.flatVectorsCapacity);
         this.flatInt8Vectors = HNSWIndex.allocateInt8(this.flatInt8VectorsCapacity * dim, this.useSharedMemory);
         for (let i = 0; i < this.nodeCount; i++) {
@@ -2602,8 +2805,7 @@ export class HNSWIndex {
                 if (!vector) {
                     throw new VectorDBError(`Cannot quantize node ${node.id}: vector is unavailable`, 'CORRUPT_INDEX');
                 }
-                this.int8Vectors[node.id] = this.scalarQuantizer.quantize(vector);
-                // Also store in contiguous buffer
+                // Store in contiguous buffer
                 this.scalarQuantizer.quantizeInto(vector, this.flatInt8Vectors, node.id * dim);
             }
         }
@@ -2844,7 +3046,7 @@ export class HNSWIndex {
     /**
      * Search layer using Int8 quantized distances for speed.
      * OPTIMIZED: Uses batch distance calculation on contiguous flatInt8Vectors.
-     * Falls back to one-by-one with int8Vectors[] if contiguous storage unavailable.
+     * Falls back to one-by-one float32 distance if contiguous int8 storage is unavailable.
      */
     searchLayerQuantized(query, nearest, layer, ef) {
         // Quantize query once — reuse pre-allocated buffer when available
@@ -2889,20 +3091,6 @@ export class HNSWIndex {
                 entryDist = -sum;
             }
         }
-        else if (int8Query) {
-            const entryInt8 = this.int8Vectors[nearest.id];
-            if (entryInt8) {
-                if (this.metric === 'cosine') {
-                    entryDist = cosineDistanceInt8(int8Query, entryInt8);
-                }
-                else if (this.metric === 'dot_product') {
-                    entryDist = -dotProductInt8(int8Query, entryInt8);
-                }
-                else {
-                    entryDist = Math.sqrt(l2SquaredInt8(int8Query, entryInt8));
-                }
-            }
-        }
         this.candidatesHeap.push(nearest.id, entryDist);
         this.resultsHeap.push(nearest.id, entryDist);
         let furthestResultDist = entryDist;
@@ -2954,38 +3142,15 @@ export class HNSWIndex {
                 }
             }
             else {
-                // Fallback: one-by-one (no contiguous storage or no quantizer)
+                // Fallback: one-by-one float32 (no contiguous int8 storage available)
                 for (const neighborId of neighbors) {
                     if (this.isVisited(neighborId))
                         continue;
                     this.markVisited(neighborId);
-                    let distance;
-                    if (int8Query) {
-                        const neighborInt8 = this.int8Vectors[neighborId];
-                        if (neighborInt8) {
-                            if (this.metric === 'cosine') {
-                                distance = cosineDistanceInt8(int8Query, neighborInt8);
-                            }
-                            else if (this.metric === 'dot_product') {
-                                distance = -dotProductInt8(int8Query, neighborInt8);
-                            }
-                            else {
-                                distance = Math.sqrt(l2SquaredInt8(int8Query, neighborInt8));
-                            }
-                        }
-                        else {
-                            const neighborVector = this.getNodeVector(neighborId);
-                            if (!neighborVector)
-                                continue;
-                            distance = this.calculateDistance(query, neighborVector);
-                        }
-                    }
-                    else {
-                        const neighborVector = this.getNodeVector(neighborId);
-                        if (!neighborVector)
-                            continue;
-                        distance = this.calculateDistance(query, neighborVector);
-                    }
+                    const neighborVector = this.getNodeVector(neighborId);
+                    if (!neighborVector)
+                        continue;
+                    const distance = this.calculateDistance(query, neighborVector);
                     if (this.resultsHeap.size() < ef || distance < furthestResultDist) {
                         this.candidatesHeap.push(neighborId, distance);
                         this.resultsHeap.push(neighborId, distance);