verso-db 0.1.1

package/dist/index.js

@@ -0,0 +1,3732 @@
+// src/backends/JsDistanceBackend.ts
+class JsDistanceBackend {
+  batchL2(base, dim, ids, query, out) {
+    const len = ids.length;
+    for (let i = 0;i < len; i++) {
+      const off = ids[i] * dim;
+      out[i] = this.l2SquaredUnrolled(base, off, query, dim);
+    }
+  }
+  batchDot(base, dim, ids, query, out) {
+    const len = ids.length;
+    for (let i = 0;i < len; i++) {
+      const off = ids[i] * dim;
+      out[i] = this.dotProductUnrolled(base, off, query, dim);
+    }
+  }
+  dotProductUnrolled(base, offset, query, dim) {
+    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+    let d = 0;
+    const limit = dim - 3;
+    for (;d < limit; d += 4) {
+      sum0 += base[offset + d] * query[d];
+      sum1 += base[offset + d + 1] * query[d + 1];
+      sum2 += base[offset + d + 2] * query[d + 2];
+      sum3 += base[offset + d + 3] * query[d + 3];
+    }
+    for (;d < dim; d++) {
+      sum0 += base[offset + d] * query[d];
+    }
+    return sum0 + sum1 + sum2 + sum3;
+  }
+  l2SquaredUnrolled(base, offset, query, dim) {
+    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+    let d = 0;
+    const limit = dim - 3;
+    for (;d < limit; d += 4) {
+      const diff0 = base[offset + d] - query[d];
+      const diff1 = base[offset + d + 1] - query[d + 1];
+      const diff2 = base[offset + d + 2] - query[d + 2];
+      const diff3 = base[offset + d + 3] - query[d + 3];
+      sum0 += diff0 * diff0;
+      sum1 += diff1 * diff1;
+      sum2 += diff2 * diff2;
+      sum3 += diff3 * diff3;
+    }
+    for (;d < dim; d++) {
+      const diff = base[offset + d] - query[d];
+      sum0 += diff * diff;
+    }
+    return sum0 + sum1 + sum2 + sum3;
+  }
+}
+function dotProductFast(a, b) {
+  const len = a.length;
+  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+  let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; i += 8) {
+    sum0 += a[i] * b[i];
+    sum1 += a[i + 1] * b[i + 1];
+    sum2 += a[i + 2] * b[i + 2];
+    sum3 += a[i + 3] * b[i + 3];
+    sum4 += a[i + 4] * b[i + 4];
+    sum5 += a[i + 5] * b[i + 5];
+    sum6 += a[i + 6] * b[i + 6];
+    sum7 += a[i + 7] * b[i + 7];
+  }
+  for (;i < len; i++) {
+    sum0 += a[i] * b[i];
+  }
+  return sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7;
+}
+function l2SquaredFast(a, b) {
+  const len = a.length;
+  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+  let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; 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;
+  }
+  for (;i < len; i++) {
+    const d = a[i] - b[i];
+    sum0 += d * d;
+  }
+  return sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7;
+}
+function normalizeInPlace(v) {
+  const len = v.length;
+  let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+  let s4 = 0, s5 = 0, s6 = 0, s7 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; i += 8) {
+    s0 += v[i] * v[i];
+    s1 += v[i + 1] * v[i + 1];
+    s2 += v[i + 2] * v[i + 2];
+    s3 += v[i + 3] * v[i + 3];
+    s4 += v[i + 4] * v[i + 4];
+    s5 += v[i + 5] * v[i + 5];
+    s6 += v[i + 6] * v[i + 6];
+    s7 += v[i + 7] * v[i + 7];
+  }
+  for (;i < len; i++) {
+    s0 += v[i] * v[i];
+  }
+  const norm = Math.sqrt(s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7);
+  if (norm > 0) {
+    const invNorm = 1 / norm;
+    for (let j = 0;j < len; j++) {
+      v[j] *= invNorm;
+    }
+  }
+  return norm;
+}
+function cosineDistanceFast(a, b, aIsNormalized = false, bIsNormalized = false) {
+  const dot = dotProductFast(a, b);
+  if (aIsNormalized && bIsNormalized) {
+    const dist2 = 1 - dot;
+    return dist2 < 0.0000000001 ? 0 : dist2;
+  }
+  const len = a.length;
+  let nA0 = 0, nA1 = 0, nA2 = 0, nA3 = 0;
+  let nB0 = 0, nB1 = 0, nB2 = 0, nB3 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; i += 8) {
+    nA0 += a[i] * a[i] + a[i + 4] * a[i + 4];
+    nA1 += a[i + 1] * a[i + 1] + a[i + 5] * a[i + 5];
+    nA2 += a[i + 2] * a[i + 2] + a[i + 6] * a[i + 6];
+    nA3 += a[i + 3] * a[i + 3] + a[i + 7] * a[i + 7];
+    nB0 += b[i] * b[i] + b[i + 4] * b[i + 4];
+    nB1 += b[i + 1] * b[i + 1] + b[i + 5] * b[i + 5];
+    nB2 += b[i + 2] * b[i + 2] + b[i + 6] * b[i + 6];
+    nB3 += b[i + 3] * b[i + 3] + b[i + 7] * b[i + 7];
+  }
+  for (;i < len; i++) {
+    nA0 += a[i] * a[i];
+    nB0 += b[i] * b[i];
+  }
+  const normA = nA0 + nA1 + nA2 + nA3;
+  const normB = nB0 + nB1 + nB2 + nB3;
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0)
+    return 1;
+  const dist = 1 - dot / magnitude;
+  return dist < 0.0000000001 ? 0 : dist;
+}
+
+// src/BinaryHeap.ts
+class BinaryHeap {
+  ids;
+  dists;
+  _size;
+  capacity;
+  lastPoppedValue = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.ids = new Uint32Array(capacity);
+    this.dists = new Float32Array(capacity);
+    this._size = 0;
+  }
+  push(id, dist) {
+    if (this._size >= this.capacity) {
+      return;
+    }
+    this.ids[this._size] = id;
+    this.dists[this._size] = dist;
+    this._size++;
+    this.heapifyUp(this._size - 1);
+  }
+  pop() {
+    if (this._size === 0)
+      return -1;
+    const result = this.ids[0];
+    this.lastPoppedValue = this.dists[0];
+    this._size--;
+    if (this._size > 0) {
+      this.ids[0] = this.ids[this._size];
+      this.dists[0] = this.dists[this._size];
+      this.heapifyDown(0);
+    }
+    return result;
+  }
+  peek() {
+    return this._size > 0 ? this.ids[0] : -1;
+  }
+  peekValue() {
+    return this._size > 0 ? this.dists[0] : Infinity;
+  }
+  getLastPoppedValue() {
+    return this.lastPoppedValue;
+  }
+  size() {
+    return this._size;
+  }
+  clear() {
+    this._size = 0;
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  getCapacity() {
+    return this.capacity;
+  }
+  heapifyUp(index) {
+    const ids = this.ids;
+    const dists = this.dists;
+    while (index > 0) {
+      const parentIndex = index - 1 >> 1;
+      if (dists[parentIndex] <= dists[index])
+        break;
+      const tmpId = ids[index];
+      ids[index] = ids[parentIndex];
+      ids[parentIndex] = tmpId;
+      const tmpDist = dists[index];
+      dists[index] = dists[parentIndex];
+      dists[parentIndex] = tmpDist;
+      index = parentIndex;
+    }
+  }
+  heapifyDown(index) {
+    const ids = this.ids;
+    const dists = this.dists;
+    const size = this._size;
+    while (true) {
+      const leftChild = (index << 1) + 1;
+      const rightChild = leftChild + 1;
+      let smallest = index;
+      if (leftChild < size && dists[leftChild] < dists[smallest]) {
+        smallest = leftChild;
+      }
+      if (rightChild < size && dists[rightChild] < dists[smallest]) {
+        smallest = rightChild;
+      }
+      if (smallest === index)
+        break;
+      const tmpId = ids[index];
+      ids[index] = ids[smallest];
+      ids[smallest] = tmpId;
+      const tmpDist = dists[index];
+      dists[index] = dists[smallest];
+      dists[smallest] = tmpDist;
+      index = smallest;
+    }
+  }
+}
+
+// src/MaxBinaryHeap.ts
+class MaxBinaryHeap {
+  ids;
+  dists;
+  _size;
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.ids = new Uint32Array(capacity);
+    this.dists = new Float32Array(capacity);
+    this._size = 0;
+  }
+  push(id, dist) {
+    if (this._size >= this.capacity) {
+      if (dist < this.dists[0]) {
+        this.ids[0] = id;
+        this.dists[0] = dist;
+        this.heapifyDown(0);
+      }
+      return;
+    }
+    this.ids[this._size] = id;
+    this.dists[this._size] = dist;
+    this._size++;
+    this.heapifyUp(this._size - 1);
+  }
+  pop() {
+    if (this._size === 0)
+      return -1;
+    const result = this.ids[0];
+    this._size--;
+    if (this._size > 0) {
+      this.ids[0] = this.ids[this._size];
+      this.dists[0] = this.dists[this._size];
+      this.heapifyDown(0);
+    }
+    return result;
+  }
+  peek() {
+    return this._size > 0 ? this.ids[0] : -1;
+  }
+  peekValue() {
+    return this._size > 0 ? this.dists[0] : -Infinity;
+  }
+  size() {
+    return this._size;
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  clear() {
+    this._size = 0;
+  }
+  getCapacity() {
+    return this.capacity;
+  }
+  heapifyUp(index) {
+    const ids = this.ids;
+    const dists = this.dists;
+    while (index > 0) {
+      const parentIndex = index - 1 >> 1;
+      if (dists[parentIndex] >= dists[index])
+        break;
+      const tmpId = ids[index];
+      ids[index] = ids[parentIndex];
+      ids[parentIndex] = tmpId;
+      const tmpDist = dists[index];
+      dists[index] = dists[parentIndex];
+      dists[parentIndex] = tmpDist;
+      index = parentIndex;
+    }
+  }
+  heapifyDown(index) {
+    const ids = this.ids;
+    const dists = this.dists;
+    const size = this._size;
+    while (true) {
+      const leftChild = (index << 1) + 1;
+      const rightChild = leftChild + 1;
+      let largest = index;
+      if (leftChild < size && dists[leftChild] > dists[largest]) {
+        largest = leftChild;
+      }
+      if (rightChild < size && dists[rightChild] > dists[largest]) {
+        largest = rightChild;
+      }
+      if (largest === index)
+        break;
+      const tmpId = ids[index];
+      ids[index] = ids[largest];
+      ids[largest] = tmpId;
+      const tmpDist = dists[index];
+      dists[index] = dists[largest];
+      dists[largest] = tmpDist;
+      index = largest;
+    }
+  }
+}
+
+// src/quantization/ScalarQuantizer.ts
+class ScalarQuantizer {
+  dimension;
+  params = null;
+  trained = false;
+  constructor(dimension) {
+    this.dimension = dimension;
+  }
+  train(vectors) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot train quantizer with empty vector set");
+    }
+    const dim = this.dimension;
+    const min = new Float32Array(dim).fill(Infinity);
+    const max = new Float32Array(dim).fill(-Infinity);
+    for (const vector of vectors) {
+      for (let d = 0;d < dim; d++) {
+        if (vector[d] < min[d])
+          min[d] = vector[d];
+        if (vector[d] > max[d])
+          max[d] = vector[d];
+      }
+    }
+    const scale = new Float32Array(dim);
+    const offset = new Float32Array(dim);
+    for (let d = 0;d < dim; d++) {
+      const range = max[d] - min[d];
+      if (range === 0) {
+        scale[d] = 1;
+        offset[d] = min[d];
+      } else {
+        scale[d] = 255 / range;
+        offset[d] = min[d];
+      }
+    }
+    this.params = { min, max, scale, offset };
+    this.trained = true;
+  }
+  isTrained() {
+    return this.trained;
+  }
+  getParams() {
+    return this.params;
+  }
+  setParams(params) {
+    this.params = params;
+    this.trained = true;
+  }
+  quantize(vector) {
+    if (!this.params) {
+      throw new Error("Quantizer not trained");
+    }
+    const dim = this.dimension;
+    const result = new Int8Array(dim);
+    const { scale, offset } = this.params;
+    for (let d = 0;d < dim; d++) {
+      const normalized = (vector[d] - offset[d]) * scale[d];
+      result[d] = Math.max(-128, Math.min(127, Math.round(normalized - 128)));
+    }
+    return result;
+  }
+  quantizeBatch(vectors) {
+    const result = new Array(vectors.length);
+    for (let i = 0;i < vectors.length; i++) {
+      result[i] = this.quantize(vectors[i]);
+    }
+    return result;
+  }
+  dequantize(vector) {
+    if (!this.params) {
+      throw new Error("Quantizer not trained");
+    }
+    const dim = this.dimension;
+    const result = new Float32Array(dim);
+    const { scale, offset } = this.params;
+    for (let d = 0;d < dim; d++) {
+      result[d] = (vector[d] + 128) / scale[d] + offset[d];
+    }
+    return result;
+  }
+  serialize() {
+    if (!this.params) {
+      throw new Error("Quantizer not trained");
+    }
+    const dim = this.dimension;
+    const buffer = new ArrayBuffer(4 + 4 * dim * 4);
+    const view = new DataView(buffer);
+    view.setInt32(0, dim, true);
+    let offset = 4;
+    for (const arr of [this.params.min, this.params.max, this.params.scale, this.params.offset]) {
+      for (let d = 0;d < dim; d++) {
+        view.setFloat32(offset, arr[d], true);
+        offset += 4;
+      }
+    }
+    return buffer;
+  }
+  static deserialize(buffer) {
+    const view = new DataView(buffer);
+    const dim = view.getInt32(0, true);
+    const quantizer = new ScalarQuantizer(dim);
+    const min = new Float32Array(dim);
+    const max = new Float32Array(dim);
+    const scale = new Float32Array(dim);
+    const offsetArr = new Float32Array(dim);
+    let offset = 4;
+    for (const arr of [min, max, scale, offsetArr]) {
+      for (let d = 0;d < dim; d++) {
+        arr[d] = view.getFloat32(offset, true);
+        offset += 4;
+      }
+    }
+    quantizer.setParams({ min, max, scale, offset: offsetArr });
+    return quantizer;
+  }
+}
+function dotProductInt8(a, b) {
+  const len = a.length;
+  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+  let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; i += 8) {
+    sum0 += a[i] * b[i];
+    sum1 += a[i + 1] * b[i + 1];
+    sum2 += a[i + 2] * b[i + 2];
+    sum3 += a[i + 3] * b[i + 3];
+    sum4 += a[i + 4] * b[i + 4];
+    sum5 += a[i + 5] * b[i + 5];
+    sum6 += a[i + 6] * b[i + 6];
+    sum7 += a[i + 7] * b[i + 7];
+  }
+  for (;i < len; i++) {
+    sum0 += a[i] * b[i];
+  }
+  return sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7;
+}
+function l2SquaredInt8(a, b) {
+  const len = a.length;
+  let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+  let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; 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;
+  }
+  for (;i < len; i++) {
+    const d = a[i] - b[i];
+    sum0 += d * d;
+  }
+  return sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7;
+}
+function cosineDistanceInt8(a, b) {
+  const len = a.length;
+  let dot0 = 0, dot1 = 0, dot2 = 0, dot3 = 0;
+  let normA0 = 0, normA1 = 0, normA2 = 0, normA3 = 0;
+  let normB0 = 0, normB1 = 0, normB2 = 0, normB3 = 0;
+  let i = 0;
+  const limit8 = len - 7;
+  for (;i < limit8; i += 8) {
+    dot0 += a[i] * b[i] + a[i + 4] * b[i + 4];
+    dot1 += a[i + 1] * b[i + 1] + a[i + 5] * b[i + 5];
+    dot2 += a[i + 2] * b[i + 2] + a[i + 6] * b[i + 6];
+    dot3 += a[i + 3] * b[i + 3] + a[i + 7] * b[i + 7];
+    normA0 += a[i] * a[i] + a[i + 4] * a[i + 4];
+    normA1 += a[i + 1] * a[i + 1] + a[i + 5] * a[i + 5];
+    normA2 += a[i + 2] * a[i + 2] + a[i + 6] * a[i + 6];
+    normA3 += a[i + 3] * a[i + 3] + a[i + 7] * a[i + 7];
+    normB0 += b[i] * b[i] + b[i + 4] * b[i + 4];
+    normB1 += b[i + 1] * b[i + 1] + b[i + 5] * b[i + 5];
+    normB2 += b[i + 2] * b[i + 2] + b[i + 6] * b[i + 6];
+    normB3 += b[i + 3] * b[i + 3] + b[i + 7] * b[i + 7];
+  }
+  for (;i < len; i++) {
+    dot0 += a[i] * b[i];
+    normA0 += a[i] * a[i];
+    normB0 += b[i] * b[i];
+  }
+  const dot = dot0 + dot1 + dot2 + dot3;
+  const normA = normA0 + normA1 + normA2 + normA3;
+  const normB = normB0 + normB1 + normB2 + normB3;
+  const magnitude = Math.sqrt(normA * normB);
+  if (magnitude === 0)
+    return 1;
+  const distance = 1 - dot / magnitude;
+  return distance < 0.0000000001 ? 0 : distance;
+}
+
+class QuantizedVectorStore {
+  quantizer;
+  vectors;
+  originalVectors;
+  keepOriginals;
+  constructor(dimension, keepOriginals = true) {
+    this.quantizer = new ScalarQuantizer(dimension);
+    this.vectors = [];
+    this.originalVectors = keepOriginals ? [] : null;
+    this.keepOriginals = keepOriginals;
+  }
+  addVectors(vectors) {
+    if (!this.quantizer.isTrained()) {
+      this.quantizer.train(vectors);
+    }
+    for (const v of vectors) {
+      this.vectors.push(this.quantizer.quantize(v));
+      if (this.keepOriginals && this.originalVectors) {
+        this.originalVectors.push(v);
+      }
+    }
+  }
+  getQuantized(index) {
+    return this.vectors[index];
+  }
+  getOriginal(index) {
+    if (!this.originalVectors)
+      return null;
+    return this.originalVectors[index];
+  }
+  size() {
+    return this.vectors.length;
+  }
+  memoryUsage() {
+    const quantized = this.vectors.reduce((sum, v) => sum + v.length, 0);
+    const original = this.originalVectors ? this.originalVectors.reduce((sum, v) => sum + v.length * 4, 0) : 0;
+    return { quantized, original, total: quantized + original };
+  }
+}
+
+// src/encoding/DeltaEncoder.ts
+function encodeVarint(value, buffer, offset) {
+  let v = value >>> 0;
+  let bytesWritten = 0;
+  while (v >= 128) {
+    buffer[offset + bytesWritten] = v & 127 | 128;
+    v >>>= 7;
+    bytesWritten++;
+  }
+  buffer[offset + bytesWritten] = v;
+  return bytesWritten + 1;
+}
+function decodeVarint(buffer, offset) {
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+  while (offset + bytesRead < buffer.length) {
+    const byte = buffer[offset + bytesRead];
+    result |= (byte & 127) << shift;
+    bytesRead++;
+    if ((byte & 128) === 0) {
+      return [result >>> 0, bytesRead];
+    }
+    shift += 7;
+    if (shift > 35) {
+      throw new Error("Varint too long");
+    }
+  }
+  throw new Error("Unexpected end of buffer");
+}
+function varintSize(value) {
+  let v = value >>> 0;
+  let size = 1;
+  while (v >= 128) {
+    v >>>= 7;
+    size++;
+  }
+  return size;
+}
+function deltaEncodeNeighbors(neighbors) {
+  if (neighbors.length === 0) {
+    return new Uint8Array(0);
+  }
+  const sorted = neighbors.slice().sort((a, b) => a - b);
+  let size = 4;
+  let prev = sorted[0];
+  for (let i = 1;i < sorted.length; i++) {
+    const delta = sorted[i] - prev;
+    size += varintSize(delta);
+    prev = sorted[i];
+  }
+  const buffer = new Uint8Array(size);
+  const view = new DataView(buffer.buffer);
+  view.setUint32(0, sorted[0], true);
+  let offset = 4;
+  prev = sorted[0];
+  for (let i = 1;i < sorted.length; i++) {
+    const delta = sorted[i] - prev;
+    offset += encodeVarint(delta, buffer, offset);
+    prev = sorted[i];
+  }
+  return buffer;
+}
+function deltaDecodeNeighbors(buffer, count) {
+  if (count === 0 || buffer.length === 0) {
+    return [];
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const neighbors = new Array(count);
+  neighbors[0] = view.getUint32(0, true);
+  let offset = 4;
+  for (let i = 1;i < count; i++) {
+    const [delta, bytesRead] = decodeVarint(buffer, offset);
+    neighbors[i] = neighbors[i - 1] + delta;
+    offset += bytesRead;
+  }
+  return neighbors;
+}
+function deltaEncodedSize(neighbors) {
+  if (neighbors.length === 0) {
+    return 0;
+  }
+  const sorted = neighbors.slice().sort((a, b) => a - b);
+  let size = 4;
+  let prev = sorted[0];
+  for (let i = 1;i < sorted.length; i++) {
+    const delta = sorted[i] - prev;
+    size += varintSize(delta);
+    prev = sorted[i];
+  }
+  return size;
+}
+
+// src/HNSWIndex.ts
+class HNSWIndex {
+  M;
+  M0;
+  efConstruction;
+  levelMult;
+  maxLevel;
+  entryPointId;
+  nodes;
+  nodeCount = 0;
+  dimension;
+  metric;
+  maxLayers;
+  distanceBackend;
+  flatVectors;
+  flatVectorsCapacity = 0;
+  searchHeap;
+  visitedArray;
+  visitedArraySize;
+  visitedGeneration = 0;
+  candidatesHeap;
+  resultsHeap;
+  selectionHeap;
+  heapCapacity;
+  vectorsAreNormalized = false;
+  distanceFn;
+  scalarQuantizer = null;
+  int8Vectors = [];
+  quantizationEnabled = false;
+  lazyLoadEnabled = false;
+  vectorOffsets = new Map;
+  vectorBuffer = null;
+  vectorsLoaded = new Set;
+  queryNormBuffer;
+  neighborSets = new Map;
+  constructionMode = false;
+  constructor(dimension, metric = "cosine", M = 24, efConstruction = 200, distanceBackend) {
+    this.dimension = dimension;
+    this.metric = metric;
+    this.M = M;
+    this.M0 = M * 2;
+    this.efConstruction = efConstruction;
+    this.levelMult = 1 / Math.log(M);
+    this.maxLevel = -1;
+    this.entryPointId = -1;
+    const initialCapacity = 1e4;
+    this.nodes = new Array(initialCapacity);
+    this.nodeCount = 0;
+    this.flatVectorsCapacity = initialCapacity;
+    this.flatVectors = new Float32Array(initialCapacity * dimension);
+    this.maxLayers = 32;
+    this.distanceBackend = distanceBackend ?? new JsDistanceBackend;
+    this.searchHeap = new BinaryHeap(1000);
+    this.visitedArraySize = 1e4;
+    this.visitedArray = new Uint8Array(this.visitedArraySize);
+    this.visitedGeneration = 1;
+    this.heapCapacity = Math.max(efConstruction * 2, 500);
+    this.candidatesHeap = new BinaryHeap(this.heapCapacity);
+    this.resultsHeap = new MaxBinaryHeap(this.heapCapacity);
+    this.selectionHeap = new BinaryHeap(Math.max(M * 2, efConstruction));
+    this.vectorsAreNormalized = metric === "cosine";
+    this.queryNormBuffer = new Float32Array(dimension);
+    if (metric === "cosine") {
+      this.distanceFn = (a, b) => {
+        const dot = dotProductFast(a, b);
+        const distance = 1 - dot;
+        return distance < 0.0000000001 ? 0 : distance;
+      };
+    } else if (metric === "euclidean") {
+      this.distanceFn = (a, b) => {
+        return Math.sqrt(l2SquaredFast(a, b));
+      };
+    } else if (metric === "dot_product") {
+      this.distanceFn = (a, b) => {
+        return -dotProductFast(a, b);
+      };
+    } else {
+      throw new Error(`Unsupported metric: ${metric}`);
+    }
+  }
+  ensureCapacity(minCapacity) {
+    if (minCapacity > this.nodes.length) {
+      const newCapacity = Math.max(this.nodes.length * 2, minCapacity);
+      const newNodes = new Array(newCapacity);
+      for (let i = 0;i < this.nodeCount; i++) {
+        newNodes[i] = this.nodes[i];
+      }
+      this.nodes = newNodes;
+    }
+    if (minCapacity > this.flatVectorsCapacity) {
+      const newCapacity = Math.max(this.flatVectorsCapacity * 2, minCapacity);
+      const newFlatVectors = new Float32Array(newCapacity * this.dimension);
+      newFlatVectors.set(this.flatVectors);
+      this.flatVectors = newFlatVectors;
+      this.flatVectorsCapacity = newCapacity;
+    }
+  }
+  getFlatVector(nodeId) {
+    const offset = nodeId * this.dimension;
+    return this.flatVectors.subarray(offset, offset + this.dimension);
+  }
+  setFlatVector(nodeId, vector) {
+    const offset = nodeId * this.dimension;
+    this.flatVectors.set(vector, offset);
+  }
+  getNode(id) {
+    return this.nodes[id];
+  }
+  setNode(node) {
+    const id = node.id;
+    this.ensureCapacity(id + 1);
+    this.nodes[id] = node;
+    this.setFlatVector(id, node.vector);
+    if (id >= this.nodeCount) {
+      this.nodeCount = id + 1;
+    }
+  }
+  batchNeighborIds = [];
+  batchDistances = [];
+  calculateDistancesBatch(query, neighborIds, outDistances) {
+    const dim = this.dimension;
+    const flatVectors = this.flatVectors;
+    for (let i = 0;i < neighborIds.length; i++) {
+      const neighborId = neighborIds[i];
+      const offset = neighborId * dim;
+      if (this.metric === "cosine") {
+        let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+        let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+        let d = 0;
+        const limit8 = dim - 7;
+        for (;d < limit8; d += 8) {
+          sum0 += flatVectors[offset + d] * query[d];
+          sum1 += flatVectors[offset + d + 1] * query[d + 1];
+          sum2 += flatVectors[offset + d + 2] * query[d + 2];
+          sum3 += flatVectors[offset + d + 3] * query[d + 3];
+          sum4 += flatVectors[offset + d + 4] * query[d + 4];
+          sum5 += flatVectors[offset + d + 5] * query[d + 5];
+          sum6 += flatVectors[offset + d + 6] * query[d + 6];
+          sum7 += flatVectors[offset + d + 7] * query[d + 7];
+        }
+        for (;d < dim; d++) {
+          sum0 += flatVectors[offset + d] * query[d];
+        }
+        const dot = sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7;
+        const dist = 1 - dot;
+        outDistances[i] = dist < 0.0000000001 ? 0 : dist;
+      } else if (this.metric === "euclidean") {
+        let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+        let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+        let d = 0;
+        const limit8 = dim - 7;
+        for (;d < limit8; d += 8) {
+          const d0 = flatVectors[offset + d] - query[d];
+          const d1 = flatVectors[offset + d + 1] - query[d + 1];
+          const d2 = flatVectors[offset + d + 2] - query[d + 2];
+          const d3 = flatVectors[offset + d + 3] - query[d + 3];
+          const d4 = flatVectors[offset + d + 4] - query[d + 4];
+          const d5 = flatVectors[offset + d + 5] - query[d + 5];
+          const d6 = flatVectors[offset + d + 6] - query[d + 6];
+          const d7 = flatVectors[offset + d + 7] - query[d + 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;
+        }
+        for (;d < dim; d++) {
+          const diff = flatVectors[offset + d] - query[d];
+          sum0 += diff * diff;
+        }
+        outDistances[i] = Math.sqrt(sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7);
+      } else {
+        let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+        let sum4 = 0, sum5 = 0, sum6 = 0, sum7 = 0;
+        let d = 0;
+        const limit8 = dim - 7;
+        for (;d < limit8; d += 8) {
+          sum0 += flatVectors[offset + d] * query[d];
+          sum1 += flatVectors[offset + d + 1] * query[d + 1];
+          sum2 += flatVectors[offset + d + 2] * query[d + 2];
+          sum3 += flatVectors[offset + d + 3] * query[d + 3];
+          sum4 += flatVectors[offset + d + 4] * query[d + 4];
+          sum5 += flatVectors[offset + d + 5] * query[d + 5];
+          sum6 += flatVectors[offset + d + 6] * query[d + 6];
+          sum7 += flatVectors[offset + d + 7] * query[d + 7];
+        }
+        for (;d < dim; d++) {
+          sum0 += flatVectors[offset + d] * query[d];
+        }
+        outDistances[i] = -(sum0 + sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7);
+      }
+    }
+  }
+  isVisited(id) {
+    if (id >= this.visitedArraySize) {
+      return false;
+    }
+    return this.visitedArray[id] === this.visitedGeneration;
+  }
+  markVisited(id) {
+    if (id >= this.visitedArraySize) {
+      const newSize = Math.max(this.visitedArraySize * 2, id + 1000);
+      const newArray = new Uint8Array(newSize);
+      newArray.set(this.visitedArray);
+      this.visitedArray = newArray;
+      this.visitedArraySize = newSize;
+    }
+    this.visitedArray[id] = this.visitedGeneration;
+  }
+  clearVisited() {
+    this.visitedGeneration++;
+    if (this.visitedGeneration > 250) {
+      this.visitedArray.fill(0);
+      this.visitedGeneration = 1;
+    }
+  }
+  normalizeVector(vector) {
+    const len = vector.length;
+    let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+    let s4 = 0, s5 = 0, s6 = 0, s7 = 0;
+    let i = 0;
+    const limit8 = len - 7;
+    for (;i < limit8; i += 8) {
+      s0 += vector[i] * vector[i];
+      s1 += vector[i + 1] * vector[i + 1];
+      s2 += vector[i + 2] * vector[i + 2];
+      s3 += vector[i + 3] * vector[i + 3];
+      s4 += vector[i + 4] * vector[i + 4];
+      s5 += vector[i + 5] * vector[i + 5];
+      s6 += vector[i + 6] * vector[i + 6];
+      s7 += vector[i + 7] * vector[i + 7];
+    }
+    for (;i < len; i++) {
+      s0 += vector[i] * vector[i];
+    }
+    const normSq = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7;
+    const norm = Math.sqrt(normSq);
+    if (norm > 0) {
+      const invNorm = 1 / norm;
+      for (let j = 0;j < len; j++) {
+        vector[j] *= invNorm;
+      }
+    }
+    return vector;
+  }
+  selectLevel() {
+    const r = Math.random();
+    const level = Math.floor(-Math.log(r) * this.levelMult);
+    return Math.min(level, this.maxLayers - 1);
+  }
+  calculateDistance(a, b) {
+    return this.distanceFn(a, b);
+  }
+  getNodeVector(nodeId) {
+    const node = this.nodes[nodeId];
+    if (!node)
+      return null;
+    if (this.lazyLoadEnabled && !this.vectorsLoaded.has(nodeId)) {
+      this.loadVector(nodeId);
+    }
+    return node.vector;
+  }
+  getLayerMaxConnections(layer) {
+    return layer === 0 ? this.M0 : this.M;
+  }
+  selectNeighbors(currentId, candidates, layer) {
+    const maxConnections = this.getLayerMaxConnections(layer);
+    this.selectionHeap.clear();
+    for (const candidate of candidates) {
+      if (candidate.id !== currentId) {
+        this.selectionHeap.push(candidate.id, candidate.distance);
+      }
+    }
+    const selected = new Array(Math.min(maxConnections, this.selectionHeap.size()));
+    let idx = 0;
+    while (idx < maxConnections && !this.selectionHeap.isEmpty()) {
+      const id = this.selectionHeap.pop();
+      if (id !== -1) {
+        selected[idx++] = id;
+      }
+    }
+    if (idx < selected.length) {
+      selected.length = idx;
+    }
+    return selected;
+  }
+  addBidirectionalConnection(fromId, toId, level) {
+    const fromNode = this.nodes[fromId];
+    const toNode = this.nodes[toId];
+    if (!fromNode || !toNode)
+      return;
+    if (!fromNode.neighbors[level]) {
+      fromNode.neighbors[level] = [];
+    }
+    if (!toNode.neighbors[level]) {
+      toNode.neighbors[level] = [];
+    }
+    if (this.constructionMode) {
+      let fromSets = this.neighborSets.get(fromId);
+      if (!fromSets) {
+        fromSets = [];
+        this.neighborSets.set(fromId, fromSets);
+      }
+      if (!fromSets[level]) {
+        fromSets[level] = new Set(fromNode.neighbors[level]);
+      }
+      let toSets = this.neighborSets.get(toId);
+      if (!toSets) {
+        toSets = [];
+        this.neighborSets.set(toId, toSets);
+      }
+      if (!toSets[level]) {
+        toSets[level] = new Set(toNode.neighbors[level]);
+      }
+      if (!fromSets[level].has(toId)) {
+        fromSets[level].add(toId);
+        fromNode.neighbors[level].push(toId);
+      }
+      if (!toSets[level].has(fromId)) {
+        toSets[level].add(fromId);
+        toNode.neighbors[level].push(fromId);
+      }
+    } else {
+      if (!fromNode.neighbors[level].includes(toId)) {
+        fromNode.neighbors[level].push(toId);
+      }
+      if (!toNode.neighbors[level].includes(fromId)) {
+        toNode.neighbors[level].push(fromId);
+      }
+    }
+  }
+  ensureHeapCapacity(ef) {
+    const requiredCapacity = Math.max(ef * 2, 100);
+    if (requiredCapacity > this.heapCapacity) {
+      this.heapCapacity = requiredCapacity;
+      this.candidatesHeap = new BinaryHeap(this.heapCapacity);
+      this.resultsHeap = new MaxBinaryHeap(this.heapCapacity);
+    }
+  }
+  searchLayer(query, nearest, layer, ef) {
+    this.clearVisited();
+    this.ensureHeapCapacity(ef);
+    this.candidatesHeap.clear();
+    this.resultsHeap.clear();
+    this.markVisited(nearest.id);
+    this.candidatesHeap.push(nearest.id, nearest.distance);
+    this.resultsHeap.push(nearest.id, nearest.distance);
+    let furthestResultDist = nearest.distance;
+    const batchIds = this.batchNeighborIds;
+    const batchDists = this.batchDistances;
+    while (!this.candidatesHeap.isEmpty()) {
+      const closestCandidateDist = this.candidatesHeap.peekValue();
+      const closestCandidateId = this.candidatesHeap.pop();
+      if (closestCandidateId === -1)
+        continue;
+      if (this.resultsHeap.size() >= ef && closestCandidateDist > furthestResultDist) {
+        break;
+      }
+      const node = this.nodes[closestCandidateId];
+      if (!node)
+        continue;
+      const neighbors = node.neighbors[layer] || [];
+      if (!this.lazyLoadEnabled) {
+        let batchCount = 0;
+        for (let i = 0;i < neighbors.length; i++) {
+          const neighborId = neighbors[i];
+          if (!this.isVisited(neighborId)) {
+            this.markVisited(neighborId);
+            batchIds[batchCount] = neighborId;
+            batchCount++;
+          }
+        }
+        if (batchCount > 0) {
+          if (batchDists.length < batchCount) {
+            this.batchDistances.length = batchCount;
+          }
+          this.calculateDistancesBatch(query, batchIds.slice(0, batchCount), batchDists);
+          for (let i = 0;i < batchCount; i++) {
+            const neighborId = batchIds[i];
+            const distance = batchDists[i];
+            if (this.resultsHeap.size() < ef || distance < furthestResultDist) {
+              this.candidatesHeap.push(neighborId, distance);
+              this.resultsHeap.push(neighborId, distance);
+              if (this.resultsHeap.size() > ef) {
+                this.resultsHeap.pop();
+              }
+              furthestResultDist = this.resultsHeap.peekValue();
+            }
+          }
+        }
+      } else {
+        for (const neighborId of neighbors) {
+          if (this.isVisited(neighborId))
+            continue;
+          this.markVisited(neighborId);
+          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);
+            if (this.resultsHeap.size() > ef) {
+              this.resultsHeap.pop();
+            }
+            furthestResultDist = this.resultsHeap.peekValue();
+          }
+        }
+      }
+    }
+    const resultCount = this.resultsHeap.size();
+    const results = new Array(resultCount);
+    let idx = resultCount - 1;
+    while (!this.resultsHeap.isEmpty()) {
+      const dist = this.resultsHeap.peekValue();
+      const id = this.resultsHeap.pop();
+      results[idx--] = { id, distance: dist };
+    }
+    return results;
+  }
+  greedySearch(query, entryNode, level) {
+    this.clearVisited();
+    let currentNode = entryNode;
+    const entryVector = this.getNodeVector(entryNode.id);
+    let currentDistance = entryVector ? this.calculateDistance(query, entryVector) : Infinity;
+    this.markVisited(currentNode.id);
+    let improved = true;
+    while (improved) {
+      improved = false;
+      const neighbors = currentNode.neighbors[level] || [];
+      for (const neighborId of neighbors) {
+        if (this.isVisited(neighborId))
+          continue;
+        this.markVisited(neighborId);
+        const neighborVector = this.getNodeVector(neighborId);
+        if (!neighborVector)
+          continue;
+        const neighborNode = this.nodes[neighborId];
+        if (!neighborNode)
+          continue;
+        const distance = this.calculateDistance(query, neighborVector);
+        if (distance < currentDistance) {
+          currentDistance = distance;
+          currentNode = neighborNode;
+          improved = true;
+        }
+      }
+    }
+    return { id: currentNode.id, distance: currentDistance };
+  }
+  async addPoint(id, vector, options) {
+    this.addPointSync(id, vector, options);
+  }
+  addPointSync(id, vector, options) {
+    let floatVector;
+    if (Array.isArray(vector)) {
+      floatVector = new Float32Array(vector);
+    } else if (this.vectorsAreNormalized && !options?.skipNormalization) {
+      floatVector = new Float32Array(vector);
+    } else {
+      floatVector = vector;
+    }
+    if (floatVector.length !== this.dimension) {
+      throw new Error(`Vector dimension ${floatVector.length} does not match expected ${this.dimension}`);
+    }
+    if (this.vectorsAreNormalized && !options?.skipNormalization) {
+      floatVector = this.normalizeVector(floatVector);
+    }
+    const level = this.selectLevel();
+    const neighbors = new Array(level + 1);
+    for (let i = 0;i <= level; i++) {
+      neighbors[i] = [];
+    }
+    const newNode = {
+      id,
+      level,
+      vector: floatVector,
+      neighbors
+    };
+    this.setNode(newNode);
+    if (this.entryPointId === -1) {
+      this.entryPointId = id;
+      this.maxLevel = level;
+      return;
+    }
+    let currentEntryPoint = this.nodes[this.entryPointId];
+    let currentBest = { id: currentEntryPoint.id, distance: this.calculateDistance(floatVector, currentEntryPoint.vector) };
+    for (let l = this.maxLevel;l > level; l--) {
+      const result = this.greedySearch(floatVector, currentEntryPoint, l);
+      if (result.distance < currentBest.distance) {
+        currentBest = result;
+        currentEntryPoint = this.nodes[currentBest.id];
+      }
+    }
+    for (let l = Math.min(level, this.maxLevel);l >= 0; l--) {
+      const searchResults = this.searchLayer(floatVector, currentBest, l, this.efConstruction);
+      const neighbors2 = this.selectNeighbors(id, searchResults, l);
+      for (const neighborId of neighbors2) {
+        this.addBidirectionalConnection(id, neighborId, l);
+      }
+      if (searchResults.length > 0) {
+        currentBest = searchResults[0];
+      }
+    }
+    if (level > this.maxLevel) {
+      this.maxLevel = level;
+      this.entryPointId = id;
+    }
+  }
+  searchKNN(query, k, efSearch) {
+    if (this.entryPointId === -1 || this.nodeCount === 0) {
+      return [];
+    }
+    if (query.length !== this.dimension) {
+      throw new Error(`Query dimension ${query.length} does not match expected ${this.dimension}`);
+    }
+    const effectiveEf = efSearch || Math.max(k * 2, 50);
+    let normalizedQuery = query;
+    if (this.vectorsAreNormalized) {
+      this.queryNormBuffer.set(query);
+      normalizedQuery = this.normalizeVector(this.queryNormBuffer);
+    }
+    let currentEntryPoint = this.nodes[this.entryPointId];
+    const entryVector = this.getNodeVector(this.entryPointId);
+    if (!entryVector)
+      return [];
+    let currentBest = { id: currentEntryPoint.id, distance: this.calculateDistance(normalizedQuery, entryVector) };
+    for (let l = this.maxLevel;l > 0; l--) {
+      const result = this.greedySearch(normalizedQuery, currentEntryPoint, l);
+      if (result.distance < currentBest.distance) {
+        currentBest = result;
+        currentEntryPoint = this.nodes[currentBest.id];
+      }
+    }
+    const candidates = this.searchLayer(normalizedQuery, currentBest, 0, effectiveEf);
+    candidates.sort((a, b) => {
+      const diff = a.distance - b.distance;
+      return diff !== 0 ? diff : a.id - b.id;
+    });
+    if (candidates.length > k)
+      candidates.length = k;
+    return candidates;
+  }
+  searchKNNBatch(queries, k, efSearch) {
+    const numQueries = queries.length;
+    if (this.entryPointId === -1 || this.nodeCount === 0) {
+      const emptyResults = new Array(numQueries);
+      for (let i = 0;i < numQueries; i++) {
+        emptyResults[i] = [];
+      }
+      return emptyResults;
+    }
+    const results = new Array(numQueries);
+    this.clearVisited();
+    for (let i = 0;i < numQueries; i++) {
+      const query = queries[i];
+      if (query.length !== this.dimension) {
+        throw new Error(`Query dimension ${query.length} does not match expected ${this.dimension}`);
+      }
+      results[i] = this.searchKNN(query, k, efSearch);
+      this.clearVisited();
+    }
+    return results;
+  }
+  searchKNNBatchFlat(queries, numQueries, k, efSearch) {
+    if (this.entryPointId === -1 || this.nodeCount === 0) {
+      return {
+        ids: new Uint32Array(numQueries * k),
+        distances: new Float32Array(numQueries * k).fill(Infinity)
+      };
+    }
+    const ids = new Uint32Array(numQueries * k);
+    const distances = new Float32Array(numQueries * k);
+    for (let q = 0;q < numQueries; q++) {
+      const queryStart = q * this.dimension;
+      const query = queries.subarray(queryStart, queryStart + this.dimension);
+      const results = this.searchKNN(query, k, efSearch);
+      const resultStart = q * k;
+      for (let i = 0;i < k; i++) {
+        if (i < results.length) {
+          ids[resultStart + i] = results[i].id;
+          distances[resultStart + i] = results[i].distance;
+        } else {
+          ids[resultStart + i] = 0;
+          distances[resultStart + i] = Infinity;
+        }
+      }
+      this.clearVisited();
+    }
+    return { ids, distances };
+  }
+  async add(vector) {
+    const id = this.nodeCount;
+    await this.addPoint(id, vector);
+    return id;
+  }
+  query(vector, k = 10) {
+    const floatVector = Array.isArray(vector) ? new Float32Array(vector) : vector;
+    return this.searchKNN(floatVector, k);
+  }
+  async addAll(vectors) {
+    const points = vectors.map((vector, i) => ({
+      id: this.nodeCount + i,
+      vector: vector instanceof Float32Array ? vector : new Float32Array(vector)
+    }));
+    await this.addPointsBulk(points);
+    return points.map((p) => p.id);
+  }
+  async addPointsBulk(points, options) {
+    this.addPointsBulkSync(points, options);
+  }
+  addPointsBulkSync(points, options) {
+    if (points.length === 0)
+      return;
+    this.constructionMode = true;
+    this.neighborSets.clear();
+    try {
+      for (const { id, vector } of points) {
+        this.addPointSync(id, vector, options);
+      }
+    } finally {
+      this.constructionMode = false;
+      this.neighborSets.clear();
+    }
+  }
+  clearConstructionCache() {
+    this.constructionMode = false;
+    this.neighborSets.clear();
+  }
+  static MAGIC = 1213092695;
+  static FORMAT_VERSION = 3;
+  static HEADER_SIZE = 40;
+  getNodesArray() {
+    const result = [];
+    for (let i = 0;i < this.nodeCount; i++) {
+      const node = this.nodes[i];
+      if (node)
+        result.push(node);
+    }
+    return result;
+  }
+  serialize() {
+    const nodeCount = this.nodeCount;
+    const nodesArray = this.getNodesArray();
+    const idToIndex = new Map;
+    for (let i = 0;i < nodesArray.length; i++) {
+      idToIndex.set(nodesArray[i].id, i);
+    }
+    const encodedNeighbors = [];
+    let totalNeighborBytes = 0;
+    for (const node of nodesArray) {
+      const nodeEncodings = [];
+      for (let l = 0;l <= node.level; l++) {
+        const neighborIndices = node.neighbors[l].map((id) => idToIndex.get(id) ?? 0);
+        const encoded = deltaEncodeNeighbors(neighborIndices);
+        nodeEncodings.push(encoded);
+        totalNeighborBytes += encoded.length;
+      }
+      encodedNeighbors.push(nodeEncodings);
+    }
+    let graphSize = HNSWIndex.HEADER_SIZE;
+    graphSize += nodeCount * 8;
+    for (const node of nodesArray) {
+      graphSize += (node.level + 1) * 8;
+    }
+    graphSize += totalNeighborBytes;
+    graphSize += nodeCount * 4;
+    const vectorDataOffset = graphSize;
+    const vectorDataSize = nodeCount * this.dimension * 4;
+    const totalSize = graphSize + vectorDataSize;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    const uint8Array = new Uint8Array(buffer);
+    let offset = 0;
+    view.setUint32(offset, HNSWIndex.MAGIC, true);
+    offset += 4;
+    view.setUint32(offset, HNSWIndex.FORMAT_VERSION, true);
+    offset += 4;
+    view.setUint32(offset, this.dimension, true);
+    offset += 4;
+    const metricCode = this.metric === "cosine" ? 0 : this.metric === "euclidean" ? 1 : 2;
+    view.setUint32(offset, metricCode, true);
+    offset += 4;
+    view.setUint32(offset, this.M, true);
+    offset += 4;
+    view.setUint32(offset, this.efConstruction, true);
+    offset += 4;
+    view.setUint32(offset, this.maxLevel, true);
+    offset += 4;
+    view.setUint32(offset, this.entryPointId, true);
+    offset += 4;
+    view.setUint32(offset, nodeCount, true);
+    offset += 4;
+    view.setUint32(offset, vectorDataOffset, true);
+    offset += 4;
+    for (let i = 0;i < nodesArray.length; i++) {
+      const node = nodesArray[i];
+      view.setUint32(offset, node.id, true);
+      offset += 4;
+      view.setUint32(offset, node.level, true);
+      offset += 4;
+    }
+    for (let i = 0;i < nodesArray.length; i++) {
+      const node = nodesArray[i];
+      const nodeEncodings = encodedNeighbors[i];
+      for (let l = 0;l <= node.level; l++) {
+        view.setUint32(offset, node.neighbors[l].length, true);
+        offset += 4;
+        view.setUint32(offset, nodeEncodings[l].length, true);
+        offset += 4;
+      }
+    }
+    for (let i = 0;i < nodesArray.length; i++) {
+      const nodeEncodings = encodedNeighbors[i];
+      for (const encoded of nodeEncodings) {
+        uint8Array.set(encoded, offset);
+        offset += encoded.length;
+      }
+    }
+    for (let i = 0;i < nodesArray.length; i++) {
+      view.setUint32(offset, i * this.dimension * 4, true);
+      offset += 4;
+    }
+    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;
+      }
+    }
+    return buffer;
+  }
+  static deserialize(buffer, options) {
+    const view = new DataView(buffer);
+    const uint8Array = new Uint8Array(buffer);
+    const lazyLoad = options?.lazyLoadVectors ?? false;
+    let offset = 0;
+    const possibleMagic = view.getUint32(0, true);
+    let formatVersion = 0;
+    if (possibleMagic === HNSWIndex.MAGIC) {
+      offset += 4;
+      formatVersion = view.getUint32(offset, true);
+      offset += 4;
+      if (formatVersion > HNSWIndex.FORMAT_VERSION) {
+        throw new Error(`Unsupported HNSW format version: ${formatVersion}. Maximum supported: ${HNSWIndex.FORMAT_VERSION}`);
+      }
+    } else {
+      formatVersion = 0;
+      offset = 0;
+    }
+    const dimension = view.getUint32(offset, true);
+    offset += 4;
+    const metricCode = view.getUint32(offset, true);
+    const metric = metricCode === 0 ? "cosine" : metricCode === 1 ? "euclidean" : "dot_product";
+    offset += 4;
+    const M = view.getUint32(offset, true);
+    offset += 4;
+    const efConstruction = view.getUint32(offset, true);
+    offset += 4;
+    const maxLevel = view.getInt32(offset, true);
+    offset += 4;
+    const entryPointId = view.getInt32(offset, true);
+    offset += 4;
+    const nodeCount = view.getUint32(offset, true);
+    offset += 4;
+    let vectorDataOffset = 0;
+    if (formatVersion >= 3) {
+      vectorDataOffset = view.getUint32(offset, true);
+      offset += 4;
+    }
+    const index = new HNSWIndex(dimension, metric, M, efConstruction);
+    index.maxLevel = maxLevel;
+    index.entryPointId = entryPointId;
+    const indexToId = new Array(nodeCount);
+    if (formatVersion >= 3) {
+      const nodeMetadata = [];
+      const neighborMetadata = [];
+      for (let i = 0;i < nodeCount; i++) {
+        const id = view.getUint32(offset, true);
+        offset += 4;
+        const level = view.getUint32(offset, true);
+        offset += 4;
+        indexToId[i] = id;
+        nodeMetadata.push({ id, level });
+      }
+      for (let i = 0;i < nodeCount; i++) {
+        const level = nodeMetadata[i].level;
+        const levelMeta = [];
+        for (let l = 0;l <= level; l++) {
+          const count = view.getUint32(offset, true);
+          offset += 4;
+          const encodedSize = view.getUint32(offset, true);
+          offset += 4;
+          levelMeta.push({ count, encodedSize });
+        }
+        neighborMetadata.push(levelMeta);
+      }
+      const nodeNeighbors = [];
+      for (let i = 0;i < nodeCount; i++) {
+        const level = nodeMetadata[i].level;
+        const neighbors = new Array(level + 1);
+        for (let l = 0;l <= level; l++) {
+          const { count, encodedSize } = neighborMetadata[i][l];
+          if (count === 0 || encodedSize === 0) {
+            neighbors[l] = [];
+          } else {
+            const encodedSlice = uint8Array.subarray(offset, offset + encodedSize);
+            const neighborIndices = deltaDecodeNeighbors(encodedSlice, count);
+            neighbors[l] = neighborIndices.map((idx) => idx >= 0 && idx < indexToId.length ? indexToId[idx] : 0);
+            offset += encodedSize;
+          }
+        }
+        nodeNeighbors.push(neighbors);
+      }
+      for (let i = 0;i < nodeCount; i++) {
+        const relativeOffset = view.getUint32(offset, true);
+        offset += 4;
+        const id = nodeMetadata[i].id;
+        index.vectorOffsets.set(id, vectorDataOffset + relativeOffset);
+      }
+      if (lazyLoad) {
+        index.lazyLoadEnabled = true;
+        index.vectorBuffer = buffer;
+        for (let i = 0;i < nodeCount; i++) {
+          const { id, level } = nodeMetadata[i];
+          const node = {
+            id,
+            level,
+            vector: new Float32Array(dimension),
+            neighbors: nodeNeighbors[i]
+          };
+          index.setNode(node);
+        }
+      } else {
+        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++) {
+            vector[j] = view.getFloat32(vectorOffset + j * 4, true);
+          }
+          const node = { id, level, vector, neighbors: nodeNeighbors[i] };
+          index.setNode(node);
+          index.vectorsLoaded.add(id);
+        }
+      }
+    } else if (formatVersion >= 2) {
+      const nodeMetadata = [];
+      const neighborMetadata = [];
+      for (let i = 0;i < nodeCount; i++) {
+        const id = view.getUint32(offset, true);
+        offset += 4;
+        const level = view.getUint32(offset, true);
+        offset += 4;
+        indexToId[i] = id;
+        const vector = new Float32Array(dimension);
+        for (let j = 0;j < dimension; j++) {
+          vector[j] = view.getFloat32(offset, true);
+          offset += 4;
+        }
+        nodeMetadata.push({ id, level, vector });
+      }
+      for (let i = 0;i < nodeCount; i++) {
+        const level = nodeMetadata[i].level;
+        const levelMeta = [];
+        for (let l = 0;l <= level; l++) {
+          const count = view.getUint32(offset, true);
+          offset += 4;
+          const encodedSize = view.getUint32(offset, true);
+          offset += 4;
+          levelMeta.push({ count, encodedSize });
+        }
+        neighborMetadata.push(levelMeta);
+      }
+      for (let i = 0;i < nodeCount; i++) {
+        const { id, level, vector } = nodeMetadata[i];
+        const neighbors = new Array(level + 1);
+        for (let l = 0;l <= level; l++) {
+          const { count, encodedSize } = neighborMetadata[i][l];
+          if (count === 0 || encodedSize === 0) {
+            neighbors[l] = [];
+          } else {
+            const encodedSlice = uint8Array.subarray(offset, offset + encodedSize);
+            const neighborIndices = deltaDecodeNeighbors(encodedSlice, count);
+            neighbors[l] = neighborIndices.map((idx) => idx >= 0 && idx < indexToId.length ? indexToId[idx] : 0);
+            offset += encodedSize;
+          }
+        }
+        const node = { id, level, vector, neighbors };
+        index.setNode(node);
+      }
+    } else {
+      for (let i = 0;i < nodeCount; i++) {
+        const id = view.getUint32(offset, true);
+        offset += 4;
+        const level = view.getUint32(offset, true);
+        offset += 4;
+        indexToId[i] = id;
+        const vector = new Float32Array(dimension);
+        for (let j = 0;j < dimension; j++) {
+          vector[j] = view.getFloat32(offset, true);
+          offset += 4;
+        }
+        const neighbors = new Array(level + 1);
+        for (let l = 0;l <= level; l++) {
+          const neighborCount = view.getUint32(offset, true);
+          offset += 4;
+          neighbors[l] = new Array(neighborCount);
+        }
+        const node = { id, level, vector, neighbors };
+        index.setNode(node);
+      }
+      for (const node of index.nodes.values()) {
+        if (!node)
+          continue;
+        for (let l = 0;l <= node.level; l++) {
+          for (let j = 0;j < node.neighbors[l].length; j++) {
+            const neighborIndex = view.getInt32(offset, true);
+            offset += 4;
+            if (neighborIndex >= 0 && neighborIndex < indexToId.length) {
+              node.neighbors[l][j] = indexToId[neighborIndex];
+            }
+          }
+        }
+      }
+    }
+    return index;
+  }
+  loadVector(nodeId) {
+    const node = this.nodes[nodeId];
+    if (!node)
+      return null;
+    if (!this.lazyLoadEnabled || this.vectorsLoaded.has(nodeId)) {
+      return node.vector;
+    }
+    if (!this.vectorBuffer)
+      return null;
+    const vectorOffset = this.vectorOffsets.get(nodeId);
+    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);
+    }
+    node.vector = vector;
+    this.vectorsLoaded.add(nodeId);
+    this.setFlatVector(nodeId, vector);
+    return vector;
+  }
+  preloadVectors(nodeIds) {
+    if (!this.lazyLoadEnabled)
+      return;
+    for (const nodeId of nodeIds) {
+      this.loadVector(nodeId);
+    }
+  }
+  isLazyLoadEnabled() {
+    return this.lazyLoadEnabled;
+  }
+  getLazyLoadStats() {
+    const totalNodes = this.nodeCount;
+    const loadedVectors = this.vectorsLoaded.size;
+    if (!this.lazyLoadEnabled) {
+      return {
+        enabled: false,
+        totalNodes,
+        loadedVectors: totalNodes,
+        memoryReduction: "0%"
+      };
+    }
+    const reduction = totalNodes > 0 ? ((1 - loadedVectors / totalNodes) * 100).toFixed(1) : "0";
+    return {
+      enabled: true,
+      totalNodes,
+      loadedVectors,
+      memoryReduction: `${reduction}%`
+    };
+  }
+  async saveToFile(filePath) {
+    const buffer = this.serialize();
+    await Bun.write(filePath, buffer);
+  }
+  static async loadFromFile(filePath) {
+    const file = Bun.file(filePath);
+    const buffer = await file.arrayBuffer();
+    return HNSWIndex.deserialize(buffer);
+  }
+  destroy() {
+    this.nodes = [];
+    this.nodeCount = 0;
+    this.flatVectors = new Float32Array(0);
+    this.flatVectorsCapacity = 0;
+  }
+  getMemoryUsage() {
+    let totalBytes = 0;
+    for (let i = 0;i < this.nodeCount; i++) {
+      const node = this.nodes[i];
+      if (!node)
+        continue;
+      totalBytes += 8;
+      totalBytes += node.vector.length * 4;
+      totalBytes += 24;
+      for (const neighborList of node.neighbors) {
+        totalBytes += neighborList.length * 4;
+        totalBytes += 16;
+      }
+    }
+    totalBytes += this.flatVectors.byteLength;
+    totalBytes += this.nodeCount * 8;
+    totalBytes += 1024;
+    return totalBytes;
+  }
+  getAllVectors() {
+    const result = new Map;
+    for (let i = 0;i < this.nodeCount; i++) {
+      const node = this.nodes[i];
+      if (node)
+        result.set(node.id, node.vector);
+    }
+    return result;
+  }
+  enableQuantization() {
+    if (this.nodeCount === 0) {
+      throw new Error("Cannot enable quantization on empty index. Add vectors first.");
+    }
+    const vectors = [];
+    for (let i = 0;i < this.nodeCount; i++) {
+      const node = this.nodes[i];
+      if (node)
+        vectors.push(node.vector);
+    }
+    this.scalarQuantizer = new ScalarQuantizer(this.dimension);
+    this.scalarQuantizer.train(vectors);
+    this.int8Vectors = new Array(this.nodeCount);
+    for (let i = 0;i < this.nodeCount; i++) {
+      const node = this.nodes[i];
+      if (node) {
+        this.int8Vectors[node.id] = this.scalarQuantizer.quantize(node.vector);
+      }
+    }
+    this.quantizationEnabled = true;
+  }
+  isQuantizationEnabled() {
+    return this.quantizationEnabled;
+  }
+  searchKNNQuantized(query, k, candidateMultiplier = 3, efSearch) {
+    if (!this.quantizationEnabled) {
+      return this.searchKNN(query, k, efSearch);
+    }
+    if (this.entryPointId === -1 || this.nodeCount === 0) {
+      return [];
+    }
+    let normalizedQuery = query;
+    if (this.vectorsAreNormalized) {
+      this.queryNormBuffer.set(query);
+      normalizedQuery = this.normalizeVector(this.queryNormBuffer);
+    }
+    const numCandidates = k * candidateMultiplier;
+    const effectiveEf = efSearch || Math.max(numCandidates * 2, 50);
+    let currentEntryPoint = this.nodes[this.entryPointId];
+    const entryVector = this.getNodeVector(this.entryPointId);
+    if (!entryVector)
+      return [];
+    let currentBest = { id: currentEntryPoint.id, distance: this.calculateDistance(normalizedQuery, entryVector) };
+    for (let l = this.maxLevel;l > 0; l--) {
+      const result = this.greedySearch(normalizedQuery, currentEntryPoint, l);
+      if (result.distance < currentBest.distance) {
+        currentBest = result;
+        currentEntryPoint = this.nodes[currentBest.id];
+      }
+    }
+    const candidates = this.searchLayerQuantized(normalizedQuery, currentBest, 0, effectiveEf);
+    const rescoreCount = Math.min(candidates.length, numCandidates);
+    const rescored = new Array(rescoreCount);
+    for (let i = 0;i < rescoreCount; i++) {
+      const c = candidates[i];
+      const nodeVector = this.getNodeVector(c.id);
+      if (nodeVector) {
+        rescored[i] = { id: c.id, distance: this.calculateDistance(normalizedQuery, nodeVector) };
+      } else {
+        rescored[i] = c;
+      }
+    }
+    rescored.sort((a, b) => a.distance - b.distance);
+    if (rescored.length > k)
+      rescored.length = k;
+    return rescored;
+  }
+  searchLayerQuantized(query, nearest, layer, ef) {
+    const int8Query = this.scalarQuantizer ? this.scalarQuantizer.quantize(query) : null;
+    this.clearVisited();
+    this.ensureHeapCapacity(ef);
+    this.candidatesHeap.clear();
+    this.resultsHeap.clear();
+    this.markVisited(nearest.id);
+    this.candidatesHeap.push(nearest.id, nearest.distance);
+    this.resultsHeap.push(nearest.id, nearest.distance);
+    let furthestResultDist = nearest.distance;
+    while (!this.candidatesHeap.isEmpty()) {
+      const closestCandidateDist = this.candidatesHeap.peekValue();
+      const closestCandidateId = this.candidatesHeap.pop();
+      if (closestCandidateId === -1)
+        continue;
+      if (this.resultsHeap.size() >= ef && closestCandidateDist > furthestResultDist) {
+        break;
+      }
+      const node = this.nodes[closestCandidateId];
+      if (!node)
+        continue;
+      const neighbors = node.neighbors[layer] || [];
+      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 {
+              distance = l2SquaredInt8(int8Query, neighborInt8);
+            }
+          } else {
+            const neighborNode = this.nodes[neighborId];
+            if (!neighborNode)
+              continue;
+            distance = this.calculateDistance(query, neighborNode.vector);
+          }
+        } else {
+          const neighborNode = this.nodes[neighborId];
+          if (!neighborNode)
+            continue;
+          distance = this.calculateDistance(query, neighborNode.vector);
+        }
+        if (this.resultsHeap.size() < ef || distance < furthestResultDist) {
+          this.candidatesHeap.push(neighborId, distance);
+          this.resultsHeap.push(neighborId, distance);
+          if (this.resultsHeap.size() > ef) {
+            this.resultsHeap.pop();
+          }
+          furthestResultDist = this.resultsHeap.peekValue();
+        }
+      }
+    }
+    const resultCount = this.resultsHeap.size();
+    const results = new Array(resultCount);
+    let idx = resultCount - 1;
+    while (!this.resultsHeap.isEmpty()) {
+      const dist = this.resultsHeap.peekValue();
+      const id = this.resultsHeap.pop();
+      results[idx--] = { id, distance: dist };
+    }
+    return results;
+  }
+  getQuantizationStats() {
+    const vectorCount = this.nodeCount;
+    const float32Size = vectorCount * this.dimension * 4;
+    if (this.quantizationEnabled) {
+      const int8Size = vectorCount * this.dimension;
+      const reduction = (float32Size / int8Size).toFixed(1);
+      return {
+        enabled: true,
+        vectorCount,
+        memoryReduction: `${reduction}x (${(float32Size / 1024 / 1024).toFixed(1)}MB → ${(int8Size / 1024 / 1024).toFixed(1)}MB)`,
+        expectedSpeedup: "3-4x for distance calculations"
+      };
+    }
+    return {
+      enabled: false,
+      vectorCount,
+      memoryReduction: "1x (no quantization)",
+      expectedSpeedup: "1x (baseline)"
+    };
+  }
+}
+
+// src/Collection.ts
+var {mkdir} = (() => ({}));
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// src/Collection.ts
+class Collection {
+  name;
+  dimension;
+  metric;
+  M;
+  efConstruction;
+  indexPath;
+  metaPath;
+  deletedPath;
+  hnsw;
+  idMap;
+  idReverseMap;
+  metadata;
+  deletedIds;
+  constructor(name, config, collectionPath) {
+    this.name = name;
+    this.dimension = config.dimension;
+    this.metric = config.metric || "cosine";
+    this.M = config.M || 16;
+    this.efConstruction = config.efConstruction || 200;
+    this.indexPath = join(collectionPath, `${name}.hnsw`);
+    this.metaPath = join(collectionPath, `${name}.meta`);
+    this.deletedPath = join(collectionPath, `${name}.deleted`);
+    this.hnsw = new HNSWIndex(config.dimension, this.metric, this.M, this.efConstruction);
+    this.idMap = new Map;
+    this.idReverseMap = new Map;
+    this.metadata = new Map;
+    this.deletedIds = new Set;
+  }
+  async init() {
+    await this.loadFromDisk();
+  }
+  async loadFromDisk() {
+    const indexFile = Bun.file(this.indexPath);
+    if (await indexFile.exists()) {
+      try {
+        this.hnsw = await HNSWIndex.loadFromFile(this.indexPath);
+      } catch (e) {
+        console.warn(`Failed to load HNSW index from ${this.indexPath}:`, e);
+      }
+    }
+    const metaFile = Bun.file(this.metaPath);
+    if (await metaFile.exists()) {
+      try {
+        const metaContent = await metaFile.text();
+        const lines = metaContent.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          const line = lines[i];
+          if (line.length === 0 || line.trim().length === 0)
+            continue;
+          try {
+            const parts = line.split("\t");
+            const id = parts[0];
+            const internalId = parseInt(parts[1], 10);
+            if (!isNaN(internalId)) {
+              this.idMap.set(id, internalId);
+              this.idReverseMap.set(internalId, id);
+              if (parts.length > 2) {
+                const metaStr = parts.slice(2).join("\t");
+                const metadata = JSON.parse(metaStr);
+                this.metadata.set(internalId, metadata);
+              }
+            }
+          } catch (e) {
+            console.warn(`Skipping malformed line in metadata file: ${line}`);
+          }
+        }
+      } catch (e) {}
+    }
+    const deletedFile = Bun.file(this.deletedPath);
+    if (await deletedFile.exists()) {
+      try {
+        const deletedContent = await deletedFile.text();
+        const deletedArray = JSON.parse(deletedContent);
+        if (Array.isArray(deletedArray)) {
+          this.deletedIds = new Set(deletedArray);
+        }
+      } catch (e) {}
+    }
+  }
+  async add(config) {
+    if (config.vectors.length !== config.ids.length) {
+      throw new Error("Number of vectors must match number of IDs");
+    }
+    if (config.metadata && config.metadata.length !== config.ids.length) {
+      throw new Error("Number of metadata entries must match number of IDs");
+    }
+    const duplicates = [];
+    for (const id of config.ids) {
+      if (this.idMap.has(id)) {
+        duplicates.push(id);
+      }
+    }
+    if (duplicates.length > 0) {
+      throw new Error(`Cannot add: IDs already exist: ${duplicates.slice(0, 5).join(", ")}${duplicates.length > 5 ? ` and ${duplicates.length - 5} more` : ""}. ` + `Use upsert() to update existing vectors.`);
+    }
+    const points = new Array(config.ids.length);
+    const startId = this.idMap.size;
+    for (let i = 0;i < config.ids.length; i++) {
+      const id = config.ids[i];
+      const vector = config.vectors[i];
+      const metadata = config.metadata ? config.metadata[i] : undefined;
+      if (vector.length !== this.dimension) {
+        throw new Error(`Vector at index ${i} has dimension ${vector.length}, expected ${this.dimension}`);
+      }
+      const numericId = startId + i;
+      this.idMap.set(id, numericId);
+      this.idReverseMap.set(numericId, id);
+      if (metadata) {
+        this.metadata.set(numericId, metadata);
+      }
+      points[i] = { id: numericId, vector: new Float32Array(vector) };
+    }
+    await this.hnsw.addPointsBulk(points);
+  }
+  async query(config) {
+    const { queryVector, k, filter, efSearch } = config;
+    if (queryVector.length !== this.dimension) {
+      throw new Error(`Query vector has dimension ${queryVector.length}, expected ${this.dimension}`);
+    }
+    const ef = efSearch || Math.max(k * 2, 50);
+    const results = this.hnsw.searchKNN(new Float32Array(queryVector), k * 2, ef);
+    let filteredResults = results;
+    if (filter) {
+      let hasFilter = false;
+      for (const _ in filter) {
+        hasFilter = true;
+        break;
+      }
+      if (hasFilter) {
+        filteredResults = results.filter((result) => {
+          const metadata2 = this.metadata.get(result.id) || {};
+          return this.matchesFilter(metadata2, filter);
+        });
+      }
+    }
+    const seenIds = new Set;
+    const deduplicatedResults = [];
+    for (const result of filteredResults) {
+      if (this.deletedIds.has(result.id))
+        continue;
+      if (!seenIds.has(result.id)) {
+        seenIds.add(result.id);
+        deduplicatedResults.push(result);
+      }
+    }
+    deduplicatedResults.sort((a, b) => a.distance - b.distance);
+    const resultCount = Math.min(deduplicatedResults.length, k);
+    const ids = new Array(resultCount);
+    const distances = new Array(resultCount);
+    const metadata = new Array(resultCount);
+    let outIdx = 0;
+    for (let i = 0;i < resultCount; i++) {
+      const result = deduplicatedResults[i];
+      const id = this.idReverseMap.get(result.id);
+      if (id) {
+        ids[outIdx] = id;
+        distances[outIdx] = result.distance;
+        metadata[outIdx] = this.metadata.get(result.id) || {};
+        outIdx++;
+      }
+    }
+    if (outIdx < resultCount) {
+      ids.length = outIdx;
+      distances.length = outIdx;
+      metadata.length = outIdx;
+    }
+    return { ids, distances, metadata };
+  }
+  async queryBatch(configs) {
+    if (configs.length === 0)
+      return [];
+    for (let i = 0;i < configs.length; i++) {
+      if (configs[i].queryVector.length !== this.dimension) {
+        throw new Error(`Query ${i} has dimension ${configs[i].queryVector.length}, expected ${this.dimension}`);
+      }
+    }
+    const queries = new Array(configs.length);
+    let k = 0;
+    let efSearch = 0;
+    for (let i = 0;i < configs.length; i++) {
+      const c = configs[i];
+      queries[i] = new Float32Array(c.queryVector);
+      if (c.k > k)
+        k = c.k;
+      const ef = c.efSearch || Math.max(c.k * 2, 50);
+      if (ef > efSearch)
+        efSearch = ef;
+    }
+    const batchResults = this.hnsw.searchKNNBatch(queries, k * 2, efSearch);
+    const results = [];
+    for (let q = 0;q < configs.length; q++) {
+      const config = configs[q];
+      const rawResults = batchResults[q];
+      let filteredResults = rawResults;
+      if (config.filter) {
+        let hasFilter = false;
+        for (const _ in config.filter) {
+          hasFilter = true;
+          break;
+        }
+        if (hasFilter) {
+          filteredResults = rawResults.filter((result) => {
+            const metadata2 = this.metadata.get(result.id) || {};
+            return this.matchesFilter(metadata2, config.filter);
+          });
+        }
+      }
+      const seenIds = new Set;
+      const deduplicatedResults = [];
+      for (const result of filteredResults) {
+        if (this.deletedIds.has(result.id))
+          continue;
+        if (!seenIds.has(result.id)) {
+          seenIds.add(result.id);
+          deduplicatedResults.push(result);
+        }
+      }
+      deduplicatedResults.sort((a, b) => a.distance - b.distance);
+      const resultCount = Math.min(deduplicatedResults.length, config.k);
+      const ids = new Array(resultCount);
+      const distances = new Array(resultCount);
+      const metadata = new Array(resultCount);
+      let outIdx = 0;
+      for (let i = 0;i < resultCount; i++) {
+        const result = deduplicatedResults[i];
+        const id = this.idReverseMap.get(result.id);
+        if (id) {
+          ids[outIdx] = id;
+          distances[outIdx] = result.distance;
+          metadata[outIdx] = this.metadata.get(result.id) || {};
+          outIdx++;
+        }
+      }
+      if (outIdx < resultCount) {
+        ids.length = outIdx;
+        distances.length = outIdx;
+        metadata.length = outIdx;
+      }
+      results.push({ ids, distances, metadata });
+    }
+    return results;
+  }
+  async queryBruteForce(config) {
+    const { queryVector, k, filter } = config;
+    if (queryVector.length !== this.dimension) {
+      throw new Error(`Query vector has dimension ${queryVector.length}, expected ${this.dimension}`);
+    }
+    const allNodes = [];
+    for (const [numericId, vector] of this.hnsw.getAllVectors()) {
+      allNodes.push({ id: numericId, vector });
+    }
+    const distances = [];
+    for (const node of allNodes) {
+      const distance = this.hnsw.calculateDistance(new Float32Array(queryVector), node.vector);
+      distances.push({ id: node.id, distance });
+    }
+    distances.sort((a, b) => a.distance - b.distance);
+    const topK = distances.slice(0, k);
+    let filteredResults = topK;
+    if (filter && Object.keys(filter).length > 0) {
+      filteredResults = [];
+      for (const result of topK) {
+        const metadata2 = this.metadata.get(result.id) || {};
+        if (this.matchesFilter(metadata2, filter)) {
+          filteredResults.push(result);
+        }
+        if (filteredResults.length >= k)
+          break;
+      }
+    }
+    const ids = [];
+    const distancesOut = [];
+    const metadata = [];
+    for (const result of filteredResults) {
+      const id = this.idReverseMap.get(result.id);
+      if (id) {
+        ids.push(id);
+        distancesOut.push(result.distance);
+        metadata.push(this.metadata.get(result.id) || {});
+      }
+    }
+    return {
+      ids,
+      distances: distancesOut,
+      metadata
+    };
+  }
+  async upsert(config) {
+    const duplicates = [];
+    for (const id of config.ids) {
+      if (this.idMap.has(id)) {
+        duplicates.push(id);
+      }
+    }
+    if (duplicates.length > 0) {
+      throw new Error(`Cannot upsert: IDs already exist: ${duplicates.join(", ")}. ` + `HNSW indices don't support efficient updates. ` + `To update vectors, create a new index without the old vectors.`);
+    }
+    await this.add(config);
+  }
+  count() {
+    return this.idMap.size - this.deletedIds.size;
+  }
+  countWithDeleted() {
+    return this.idMap.size;
+  }
+  deletedCount() {
+    return this.deletedIds.size;
+  }
+  delete(id) {
+    const numericId = this.idMap.get(id);
+    if (numericId === undefined)
+      return false;
+    if (this.deletedIds.has(numericId))
+      return false;
+    this.deletedIds.add(numericId);
+    return true;
+  }
+  deleteBatch(ids) {
+    let deleted = 0;
+    for (const id of ids) {
+      if (this.delete(id))
+        deleted++;
+    }
+    return deleted;
+  }
+  has(id) {
+    const numericId = this.idMap.get(id);
+    if (numericId === undefined)
+      return false;
+    return !this.deletedIds.has(numericId);
+  }
+  isDeleted(id) {
+    const numericId = this.idMap.get(id);
+    if (numericId === undefined)
+      return false;
+    return this.deletedIds.has(numericId);
+  }
+  async saveToDisk() {
+    const dirPath = dirname(this.indexPath);
+    await mkdir(dirPath, { recursive: true }).catch(() => {});
+    await this.hnsw.saveToFile(this.indexPath);
+    const metaLines = [];
+    for (const [numericId, id] of this.idReverseMap) {
+      const meta = this.metadata.get(numericId);
+      const metaStr = meta ? JSON.stringify(meta) : "{}";
+      metaLines.push(`${id}	${numericId}	${metaStr}`);
+    }
+    await Bun.write(this.metaPath, metaLines.join(`
+`));
+    if (this.deletedIds.size > 0) {
+      await Bun.write(this.deletedPath, JSON.stringify([...this.deletedIds]));
+    } else {
+      const deletedFile = Bun.file(this.deletedPath);
+      if (await deletedFile.exists()) {
+        await Bun.write(this.deletedPath, "[]");
+      }
+    }
+  }
+  matchesFilter(metadata, filter) {
+    for (const key in filter) {
+      const value = filter[key];
+      const metaValue = metadata[key];
+      if (typeof value === "object" && value !== null) {
+        if (value.$gt !== undefined && metaValue <= value.$gt)
+          return false;
+        if (value.$lt !== undefined && metaValue >= value.$lt)
+          return false;
+        if (value.$gte !== undefined && metaValue < value.$gte)
+          return false;
+        if (value.$lte !== undefined && metaValue > value.$lte)
+          return false;
+        if (value.$ne !== undefined && metaValue === value.$ne)
+          return false;
+        if (value.$in !== undefined && !value.$in.includes(metaValue))
+          return false;
+        if (value.$nin !== undefined && value.$nin.includes(metaValue))
+          return false;
+      } else {
+        if (metaValue !== value)
+          return false;
+      }
+    }
+    return true;
+  }
+  async compact() {
+    if (this.deletedIds.size === 0)
+      return 0;
+    const removedCount = this.deletedIds.size;
+    const activeVectors = [];
+    for (const [numericId, vector] of this.hnsw.getAllVectors()) {
+      if (!this.deletedIds.has(numericId)) {
+        const stringId = this.idReverseMap.get(numericId);
+        if (stringId) {
+          activeVectors.push({
+            id: stringId,
+            numericId,
+            vector,
+            meta: this.metadata.get(numericId)
+          });
+        }
+      }
+    }
+    this.hnsw.destroy();
+    this.hnsw = new HNSWIndex(this.dimension, this.metric, this.M, this.efConstruction);
+    this.idMap.clear();
+    this.idReverseMap.clear();
+    this.metadata.clear();
+    this.deletedIds.clear();
+    const points = new Array(activeVectors.length);
+    for (let i = 0;i < activeVectors.length; i++) {
+      const { id, vector, meta } = activeVectors[i];
+      const newNumericId = i;
+      this.idMap.set(id, newNumericId);
+      this.idReverseMap.set(newNumericId, id);
+      if (meta) {
+        this.metadata.set(newNumericId, meta);
+      }
+      points[i] = { id: newNumericId, vector };
+    }
+    await this.hnsw.addPointsBulk(points);
+    return removedCount;
+  }
+  async destroy() {
+    await this.saveToDisk();
+    if (this.hnsw && typeof this.hnsw.destroy === "function") {
+      this.hnsw.destroy();
+    }
+    this.idMap.clear();
+    this.idReverseMap.clear();
+    this.metadata.clear();
+    this.deletedIds.clear();
+  }
+}
+
+// src/storage/BunStorageBackend.ts
+var {mkdir: mkdir2, readdir, unlink, rm, appendFile} = (() => ({}));
+class BunStorageBackend {
+  type = "bun";
+  basePath;
+  dirCache = new Set;
+  constructor(basePath = "./vectordb_data") {
+    this.basePath = basePath;
+  }
+  async ensureDir(dir) {
+    if (this.dirCache.has(dir))
+      return;
+    await mkdir2(dir, { recursive: true }).catch(() => {});
+    this.dirCache.add(dir);
+  }
+  getFullPath(key) {
+    return join(this.basePath, key);
+  }
+  async init() {
+    await mkdir2(this.basePath, { recursive: true }).catch(() => {});
+  }
+  async read(key) {
+    const fullPath = this.getFullPath(key);
+    const file = Bun.file(fullPath);
+    if (!await file.exists()) {
+      return null;
+    }
+    return file.arrayBuffer();
+  }
+  async write(key, data) {
+    const fullPath = this.getFullPath(key);
+    await this.ensureDir(dirname(fullPath));
+    await Bun.write(fullPath, data);
+  }
+  async append(key, data) {
+    const fullPath = this.getFullPath(key);
+    await this.ensureDir(dirname(fullPath));
+    const appendData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    await appendFile(fullPath, appendData);
+  }
+  async delete(key) {
+    const fullPath = this.getFullPath(key);
+    try {
+      await unlink(fullPath);
+    } catch {}
+  }
+  async exists(key) {
+    const fullPath = this.getFullPath(key);
+    const file = Bun.file(fullPath);
+    return file.exists();
+  }
+  async list(prefix) {
+    const searchPath = prefix ? this.getFullPath(prefix) : this.basePath;
+    try {
+      const entries = await readdir(searchPath, { recursive: true });
+      return entries.map((entry) => {
+        const fullPath = join(searchPath, entry);
+        return relative(this.basePath, fullPath);
+      });
+    } catch {
+      return [];
+    }
+  }
+  async mkdir(dirPath) {
+    const fullPath = this.getFullPath(dirPath);
+    await mkdir2(fullPath, { recursive: true }).catch(() => {});
+  }
+  async clear() {
+    await rm(this.basePath, { recursive: true, force: true }).catch(() => {});
+    await mkdir2(this.basePath, { recursive: true }).catch(() => {});
+    this.dirCache.clear();
+    this.dirCache.add(this.basePath);
+  }
+  async size(key) {
+    const fullPath = this.getFullPath(key);
+    const file = Bun.file(fullPath);
+    if (!await file.exists()) {
+      return 0;
+    }
+    return file.size;
+  }
+  stream(key) {
+    const fullPath = this.getFullPath(key);
+    const file = Bun.file(fullPath);
+    return file.stream();
+  }
+  getBasePath() {
+    return this.basePath;
+  }
+}
+
+// src/VectorDB.ts
+class VectorDB {
+  collections;
+  storagePath;
+  storageBackend;
+  initialized = false;
+  constructor(config) {
+    this.collections = new Map;
+    this.storagePath = config?.storagePath || "./vectordb_data";
+    this.storageBackend = config?.storageBackend || new BunStorageBackend(this.storagePath);
+  }
+  getStorageBackend() {
+    return this.storageBackend;
+  }
+  async init() {
+    if (this.initialized)
+      return;
+    await this.storageBackend.mkdir("");
+    this.initialized = true;
+  }
+  async createCollection(name, config) {
+    await this.init();
+    if (this.collections.has(name)) {
+      throw new Error(`Collection ${name} already exists`);
+    }
+    const collectionPath = join(this.storagePath, name);
+    await this.storageBackend.mkdir(name);
+    const collection = new Collection(name, config, collectionPath);
+    await collection.init();
+    this.collections.set(name, collection);
+    return collection;
+  }
+  getCollection(name) {
+    return this.collections.get(name);
+  }
+  async listCollections() {
+    return [...this.collections.keys()];
+  }
+  async deleteCollection(name) {
+    const collection = this.collections.get(name);
+    if (!collection) {
+      throw new Error(`Collection ${name} does not exist`);
+    }
+    await collection.destroy();
+    this.collections.delete(name);
+  }
+  async close() {
+    for (const collection of this.collections.values()) {
+      await collection.destroy();
+    }
+    this.collections.clear();
+  }
+}
+// src/presets.ts
+var PRESET_LOW_DIM = {
+  name: "low-dim",
+  description: "Optimized for low-dimensional vectors (<=128D)",
+  M: 16,
+  efConstruction: 200,
+  efSearch: 100,
+  expectedRecall: 0.99,
+  targetDimensions: "<=128",
+  targetDatasetSize: "1K-100K"
+};
+var PRESET_MEDIUM_DIM = {
+  name: "medium-dim",
+  description: "Optimized for medium-dimensional vectors (256-512D)",
+  M: 24,
+  efConstruction: 200,
+  efSearch: 150,
+  expectedRecall: 0.97,
+  targetDimensions: "256-512",
+  targetDatasetSize: "1K-100K"
+};
+var PRESET_HIGH_DIM = {
+  name: "high-dim",
+  description: "Optimized for high-dimensional vectors (768D+)",
+  M: 32,
+  efConstruction: 200,
+  efSearch: 128,
+  expectedRecall: 0.99,
+  targetDimensions: ">=768",
+  targetDatasetSize: "1K-500K"
+};
+var PRESET_VERY_HIGH_DIM = {
+  name: "very-high-dim",
+  description: "Optimized for very high-dimensional vectors (1536D+)",
+  M: 48,
+  efConstruction: 300,
+  efSearch: 150,
+  expectedRecall: 0.99,
+  targetDimensions: ">=1536",
+  targetDatasetSize: "1K-500K"
+};
+var PRESET_SMALL_DATASET = {
+  name: "small-dataset",
+  description: "Optimized for small datasets (<10K vectors)",
+  M: 16,
+  efConstruction: 200,
+  efSearch: 200,
+  expectedRecall: 0.99,
+  targetDimensions: "any",
+  targetDatasetSize: "<10K"
+};
+var PRESET_LARGE_DATASET = {
+  name: "large-dataset",
+  description: "Optimized for large datasets (100K-1M vectors)",
+  M: 32,
+  efConstruction: 200,
+  efSearch: 128,
+  expectedRecall: 0.99,
+  targetDimensions: "any",
+  targetDatasetSize: "100K-1M"
+};
+var PRESET_MAX_RECALL = {
+  name: "max-recall",
+  description: "Maximum recall configuration",
+  M: 48,
+  efConstruction: 500,
+  efSearch: 400,
+  expectedRecall: 0.99,
+  targetDimensions: "any",
+  targetDatasetSize: "any"
+};
+var PRESET_LOW_LATENCY = {
+  name: "low-latency",
+  description: "Minimum latency configuration (90% recall)",
+  M: 12,
+  efConstruction: 100,
+  efSearch: 50,
+  expectedRecall: 0.9,
+  targetDimensions: "any",
+  targetDatasetSize: "any"
+};
+var PRESETS = {
+  "low-dim": PRESET_LOW_DIM,
+  "medium-dim": PRESET_MEDIUM_DIM,
+  "high-dim": PRESET_HIGH_DIM,
+  "very-high-dim": PRESET_VERY_HIGH_DIM,
+  "small-dataset": PRESET_SMALL_DATASET,
+  "large-dataset": PRESET_LARGE_DATASET,
+  "max-recall": PRESET_MAX_RECALL,
+  "low-latency": PRESET_LOW_LATENCY
+};
+function getRecommendedPreset(dimension, datasetSize) {
+  if (dimension >= 1536)
+    return PRESET_VERY_HIGH_DIM;
+  if (dimension >= 768)
+    return PRESET_HIGH_DIM;
+  if (datasetSize !== undefined) {
+    if (datasetSize < 1e4)
+      return PRESET_SMALL_DATASET;
+    if (datasetSize > 1e5)
+      return PRESET_LARGE_DATASET;
+  }
+  if (dimension <= 128)
+    return PRESET_LOW_DIM;
+  if (dimension <= 512)
+    return PRESET_MEDIUM_DIM;
+  return PRESET_HIGH_DIM;
+}
+function getPreset(name) {
+  return PRESETS[name];
+}
+function getRAGPreset(embeddingModel) {
+  const model = embeddingModel.toLowerCase();
+  if (model.includes("ada-002") || model.includes("text-embedding-3")) {
+    return PRESET_VERY_HIGH_DIM;
+  }
+  if (model.includes("cohere") || model.includes("embed-")) {
+    return PRESET_HIGH_DIM;
+  }
+  if (model.includes("bert") || model.includes("minilm") || model.includes("mpnet")) {
+    return PRESET_HIGH_DIM;
+  }
+  if (model.includes("e5-")) {
+    return model.includes("large") ? PRESET_HIGH_DIM : PRESET_MEDIUM_DIM;
+  }
+  return PRESET_HIGH_DIM;
+}
+// src/storage/MemoryBackend.ts
+class MemoryBackend {
+  type = "memory";
+  storage = new Map;
+  directories = new Set;
+  constructor() {
+    this.directories.add("");
+  }
+  async read(key) {
+    const data = this.storage.get(key);
+    if (!data)
+      return null;
+    return data.slice(0);
+  }
+  async write(key, data) {
+    const buffer = data instanceof ArrayBuffer ? data : data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    this.storage.set(key, buffer.slice(0));
+  }
+  async append(key, data) {
+    const appendData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const existing = this.storage.get(key);
+    if (existing) {
+      const existingArray = new Uint8Array(existing);
+      const combined = new Uint8Array(existingArray.length + appendData.length);
+      combined.set(existingArray, 0);
+      combined.set(appendData, existingArray.length);
+      this.storage.set(key, combined.buffer.slice(0));
+    } else {
+      this.storage.set(key, appendData.buffer.slice(appendData.byteOffset, appendData.byteOffset + appendData.byteLength));
+    }
+  }
+  async delete(key) {
+    this.storage.delete(key);
+  }
+  async exists(key) {
+    return this.storage.has(key) || this.directories.has(key);
+  }
+  async list(prefix) {
+    const keys = [];
+    for (const key of this.storage.keys()) {
+      if (!prefix || key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  async mkdir(path) {
+    this.directories.add(path);
+    const parts = path.split("/");
+    for (let i = 1;i <= parts.length; i++) {
+      this.directories.add(parts.slice(0, i).join("/"));
+    }
+  }
+  clear() {
+    this.storage.clear();
+    this.directories.clear();
+    this.directories.add("");
+  }
+  getStats() {
+    let totalBytes = 0;
+    for (const value of this.storage.values()) {
+      totalBytes += value.byteLength;
+    }
+    return {
+      keyCount: this.storage.size,
+      totalBytes
+    };
+  }
+  export() {
+    const result = {};
+    for (const [key, value] of this.storage.entries()) {
+      result[key] = value.slice(0);
+    }
+    return result;
+  }
+  import(data) {
+    for (const [key, value] of Object.entries(data)) {
+      this.storage.set(key, value.slice(0));
+    }
+  }
+}
+// src/storage/OPFSBackend.ts
+class OPFSBackend {
+  type = "opfs";
+  root = null;
+  initialized = false;
+  async init() {
+    if (this.initialized)
+      return;
+    if (typeof navigator === "undefined" || !navigator.storage?.getDirectory) {
+      throw new Error("OPFS not available in this environment. Use MemoryBackend or IndexedDBBackend instead.");
+    }
+    this.root = await navigator.storage.getDirectory();
+    this.initialized = true;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  async getFileHandle(key, create = false) {
+    await this.ensureInitialized();
+    const parts = key.split("/");
+    const fileName = parts.pop();
+    let currentDir = this.root;
+    for (const part of parts) {
+      if (part === "")
+        continue;
+      try {
+        currentDir = await currentDir.getDirectoryHandle(part, { create });
+      } catch {
+        if (!create)
+          return null;
+        throw new Error(`Failed to create directory: ${part}`);
+      }
+    }
+    try {
+      return await currentDir.getFileHandle(fileName, { create });
+    } catch {
+      return null;
+    }
+  }
+  async getDirectoryHandle(path, create = false) {
+    await this.ensureInitialized();
+    const parts = path.split("/").filter((p) => p !== "");
+    let currentDir = this.root;
+    for (const part of parts) {
+      try {
+        currentDir = await currentDir.getDirectoryHandle(part, { create });
+      } catch {
+        if (!create)
+          return null;
+        throw new Error(`Failed to get directory: ${part}`);
+      }
+    }
+    return currentDir;
+  }
+  async read(key) {
+    await this.ensureInitialized();
+    const handle = await this.getFileHandle(key, false);
+    if (!handle)
+      return null;
+    try {
+      const file = await handle.getFile();
+      return file.arrayBuffer();
+    } catch {
+      return null;
+    }
+  }
+  async write(key, data) {
+    await this.ensureInitialized();
+    const handle = await this.getFileHandle(key, true);
+    if (!handle) {
+      throw new Error(`Failed to create file: ${key}`);
+    }
+    const writable = await handle.createWritable();
+    try {
+      const writeData = data instanceof ArrayBuffer ? data : data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      await writable.write(writeData);
+    } finally {
+      await writable.close();
+    }
+  }
+  async append(key, data) {
+    await this.ensureInitialized();
+    const handle = await this.getFileHandle(key, true);
+    if (!handle) {
+      throw new Error(`Failed to create file: ${key}`);
+    }
+    const appendData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    let existingSize = 0;
+    try {
+      const file = await handle.getFile();
+      existingSize = file.size;
+    } catch {
+      existingSize = 0;
+    }
+    const writable = await handle.createWritable({ keepExistingData: true });
+    try {
+      await writable.seek(existingSize);
+      const writeData = appendData.buffer.slice(appendData.byteOffset, appendData.byteOffset + appendData.byteLength);
+      await writable.write(writeData);
+    } finally {
+      await writable.close();
+    }
+  }
+  async delete(key) {
+    await this.ensureInitialized();
+    const parts = key.split("/");
+    const fileName = parts.pop();
+    let currentDir = this.root;
+    for (const part of parts) {
+      if (part === "")
+        continue;
+      try {
+        currentDir = await currentDir.getDirectoryHandle(part, { create: false });
+      } catch {
+        return;
+      }
+    }
+    try {
+      await currentDir.removeEntry(fileName);
+    } catch {}
+  }
+  async exists(key) {
+    await this.ensureInitialized();
+    const handle = await this.getFileHandle(key, false);
+    return handle !== null;
+  }
+  async list(prefix) {
+    await this.ensureInitialized();
+    const results = [];
+    const basePath = prefix || "";
+    const dir = basePath ? await this.getDirectoryHandle(basePath, false) : this.root;
+    if (!dir)
+      return results;
+    const listDir = async (dirHandle, pathPrefix) => {
+      for await (const entry of dirHandle.values()) {
+        const entryPath = pathPrefix ? `${pathPrefix}/${entry.name}` : entry.name;
+        if (entry.kind === "file") {
+          results.push(entryPath);
+        } else if (entry.kind === "directory") {
+          await listDir(entry, entryPath);
+        }
+      }
+    };
+    await listDir(dir, basePath);
+    return results;
+  }
+  async mkdir(path) {
+    await this.ensureInitialized();
+    await this.getDirectoryHandle(path, true);
+  }
+  async clear() {
+    await this.ensureInitialized();
+    for await (const entry of this.root.values()) {
+      await this.root.removeEntry(entry.name, { recursive: true });
+    }
+  }
+  static isAvailable() {
+    return typeof navigator !== "undefined" && !!navigator.storage?.getDirectory;
+  }
+}
+// src/storage/createStorageBackend.ts
+function detectEnvironment() {
+  if (typeof Bun !== "undefined") {
+    return "bun";
+  }
+  if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+async function createStorageBackend(options) {
+  const type = options?.type ?? "auto";
+  if (type === "bun") {
+    const backend = new BunStorageBackend(options?.path ?? "./vectordb_data");
+    await backend.init();
+    return backend;
+  }
+  if (type === "opfs") {
+    if (!OPFSBackend.isAvailable()) {
+      throw new Error("OPFS not available in this environment");
+    }
+    const backend = new OPFSBackend;
+    await backend.init();
+    return backend;
+  }
+  if (type === "memory") {
+    return new MemoryBackend;
+  }
+  const env = detectEnvironment();
+  if (env === "bun") {
+    const backend = new BunStorageBackend(options?.path ?? "./vectordb_data");
+    await backend.init();
+    return backend;
+  }
+  if (env === "browser") {
+    if (OPFSBackend.isAvailable()) {
+      try {
+        const backend = new OPFSBackend;
+        await backend.init();
+        return backend;
+      } catch {}
+    }
+  }
+  return new MemoryBackend;
+}
+function getRecommendedStorageType() {
+  const env = detectEnvironment();
+  if (env === "bun") {
+    return "bun";
+  }
+  if (env === "browser" && OPFSBackend.isAvailable()) {
+    return "opfs";
+  }
+  return "memory";
+}
+function isStorageTypeAvailable(type) {
+  switch (type) {
+    case "bun":
+      return typeof Bun !== "undefined";
+    case "opfs":
+      return OPFSBackend.isAvailable();
+    case "memory":
+      return true;
+    case "auto":
+      return true;
+    default:
+      return false;
+  }
+}
+// src/storage/WriteAheadLog.ts
+var {appendFile: appendFile2, mkdir: mkdir3, unlink: unlink2} = (() => ({}));
+var WALOperationType;
+((WALOperationType2) => {
+  WALOperationType2[WALOperationType2["ADD_VECTOR"] = 1] = "ADD_VECTOR";
+  WALOperationType2[WALOperationType2["ADD_NEIGHBORS"] = 2] = "ADD_NEIGHBORS";
+  WALOperationType2[WALOperationType2["UPDATE_ENTRY_POINT"] = 3] = "UPDATE_ENTRY_POINT";
+  WALOperationType2[WALOperationType2["CHECKPOINT"] = 4] = "CHECKPOINT";
+})(WALOperationType ||= {});
+
+class WriteAheadLog {
+  logPath;
+  pendingEntries = [];
+  flushThreshold;
+  lastFlushTime = 0;
+  entryCount = 0;
+  constructor(basePath, flushThreshold = 100) {
+    this.logPath = `${basePath}.wal`;
+    this.flushThreshold = flushThreshold;
+  }
+  getPath() {
+    return this.logPath;
+  }
+  async exists() {
+    const file = Bun.file(this.logPath);
+    return file.exists();
+  }
+  async appendVector(id, vector) {
+    const dataSize = 4 + 4 + vector.length * 4;
+    const buffer = new ArrayBuffer(dataSize);
+    const view = new DataView(buffer);
+    view.setUint32(0, id, true);
+    view.setUint32(4, vector.length, true);
+    const floatView = new Float32Array(buffer, 8);
+    floatView.set(vector);
+    const entry = {
+      type: 1 /* ADD_VECTOR */,
+      timestamp: Date.now(),
+      data: buffer
+    };
+    this.pendingEntries.push(entry);
+    this.entryCount++;
+    if (this.pendingEntries.length >= this.flushThreshold) {
+      await this.flush();
+    }
+  }
+  async appendNeighbors(nodeId, layer, neighbors) {
+    const dataSize = 4 + 4 + 4 + neighbors.length * 4;
+    const buffer = new ArrayBuffer(dataSize);
+    const view = new DataView(buffer);
+    view.setUint32(0, nodeId, true);
+    view.setUint32(4, layer, true);
+    view.setUint32(8, neighbors.length, true);
+    let offset = 12;
+    for (const neighbor of neighbors) {
+      view.setUint32(offset, neighbor, true);
+      offset += 4;
+    }
+    const entry = {
+      type: 2 /* ADD_NEIGHBORS */,
+      timestamp: Date.now(),
+      data: buffer
+    };
+    this.pendingEntries.push(entry);
+    this.entryCount++;
+    if (this.pendingEntries.length >= this.flushThreshold) {
+      await this.flush();
+    }
+  }
+  async appendEntryPointUpdate(entryPointId, maxLevel) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setInt32(0, entryPointId, true);
+    view.setInt32(4, maxLevel, true);
+    const entry = {
+      type: 3 /* UPDATE_ENTRY_POINT */,
+      timestamp: Date.now(),
+      data: buffer
+    };
+    this.pendingEntries.push(entry);
+    this.entryCount++;
+    if (this.pendingEntries.length >= this.flushThreshold) {
+      await this.flush();
+    }
+  }
+  async checkpoint() {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, Date.now(), true);
+    const entry = {
+      type: 4 /* CHECKPOINT */,
+      timestamp: Date.now(),
+      data: buffer
+    };
+    this.pendingEntries.push(entry);
+    await this.flush();
+  }
+  serializeEntry(entry) {
+    const headerSize = 1 + 8 + 4;
+    const totalSize = headerSize + entry.data.byteLength;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    view.setUint8(0, entry.type);
+    view.setFloat64(1, entry.timestamp, true);
+    view.setUint32(9, entry.data.byteLength, true);
+    const dataView = new Uint8Array(buffer, headerSize);
+    dataView.set(new Uint8Array(entry.data));
+    return new Uint8Array(buffer);
+  }
+  async flush() {
+    if (this.pendingEntries.length === 0)
+      return;
+    const serializedEntries = this.pendingEntries.map((e) => this.serializeEntry(e));
+    let totalSize = 0;
+    for (const entry of serializedEntries) {
+      totalSize += entry.length;
+    }
+    const combined = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const entry of serializedEntries) {
+      combined.set(entry, offset);
+      offset += entry.length;
+    }
+    const dir = dirname(this.logPath);
+    await mkdir3(dir, { recursive: true }).catch(() => {});
+    await appendFile2(this.logPath, combined);
+    this.pendingEntries = [];
+    this.lastFlushTime = Date.now();
+  }
+  async readEntries() {
+    const file = Bun.file(this.logPath);
+    if (!await file.exists()) {
+      return [];
+    }
+    const buffer = await file.arrayBuffer();
+    const view = new DataView(buffer);
+    const entries = [];
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+      const type = view.getUint8(offset);
+      const timestamp = view.getFloat64(offset + 1, true);
+      const dataLength = view.getUint32(offset + 9, true);
+      const data = buffer.slice(offset + 13, offset + 13 + dataLength);
+      entries.push({ type, timestamp, data });
+      offset += 13 + dataLength;
+    }
+    return entries;
+  }
+  static parseVectorEntry(data) {
+    const view = new DataView(data);
+    const id = view.getUint32(0, true);
+    const vectorLength = view.getUint32(4, true);
+    const vector = new Float32Array(data, 8, vectorLength);
+    return { id, vector };
+  }
+  static parseNeighborsEntry(data) {
+    const view = new DataView(data);
+    const nodeId = view.getUint32(0, true);
+    const layer = view.getUint32(4, true);
+    const neighborCount = view.getUint32(8, true);
+    const neighbors = [];
+    for (let i = 0;i < neighborCount; i++) {
+      neighbors.push(view.getUint32(12 + i * 4, true));
+    }
+    return { nodeId, layer, neighbors };
+  }
+  static parseEntryPointEntry(data) {
+    const view = new DataView(data);
+    return {
+      entryPointId: view.getInt32(0, true),
+      maxLevel: view.getInt32(4, true)
+    };
+  }
+  getEntryCount() {
+    return this.entryCount;
+  }
+  async clear() {
+    const file = Bun.file(this.logPath);
+    if (await file.exists()) {
+      await Bun.write(this.logPath, new Uint8Array(0));
+    }
+    this.pendingEntries = [];
+    this.entryCount = 0;
+  }
+  async delete() {
+    try {
+      await unlink2(this.logPath);
+    } catch {}
+    this.pendingEntries = [];
+    this.entryCount = 0;
+  }
+}
+// src/storage/BatchWriter.ts
+class BatchWriter {
+  backend;
+  pendingWrites = new Map;
+  pendingAppends = new Map;
+  pendingBytes = 0;
+  maxPendingWrites;
+  maxPendingBytes;
+  autoFlushInterval;
+  flushTimer = null;
+  isFlushing = false;
+  flushPromise = null;
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.maxPendingWrites = options.maxPendingWrites ?? 100;
+    this.maxPendingBytes = options.maxPendingBytes ?? 1024 * 1024;
+    this.autoFlushInterval = options.autoFlushInterval ?? 0;
+    if (this.autoFlushInterval > 0) {
+      this.startAutoFlush();
+    }
+  }
+  async write(key, data) {
+    const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const existing = this.pendingWrites.get(key);
+    if (existing) {
+      this.pendingBytes -= existing.data.length;
+    }
+    const existingAppends = this.pendingAppends.get(key);
+    if (existingAppends) {
+      for (const append of existingAppends) {
+        this.pendingBytes -= append.length;
+      }
+      this.pendingAppends.delete(key);
+    }
+    this.pendingWrites.set(key, {
+      key,
+      data: bytes,
+      append: false
+    });
+    this.pendingBytes += bytes.length;
+    await this.checkThresholds();
+  }
+  async append(key, data) {
+    const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const existingWrite = this.pendingWrites.get(key);
+    if (existingWrite) {
+      const newData = new Uint8Array(existingWrite.data.length + bytes.length);
+      newData.set(existingWrite.data);
+      newData.set(bytes, existingWrite.data.length);
+      this.pendingBytes -= existingWrite.data.length;
+      this.pendingBytes += newData.length;
+      existingWrite.data = newData;
+    } else {
+      let appends = this.pendingAppends.get(key);
+      if (!appends) {
+        appends = [];
+        this.pendingAppends.set(key, appends);
+      }
+      appends.push(bytes);
+      this.pendingBytes += bytes.length;
+    }
+    await this.checkThresholds();
+  }
+  async delete(key) {
+    const existing = this.pendingWrites.get(key);
+    if (existing) {
+      this.pendingBytes -= existing.data.length;
+      this.pendingWrites.delete(key);
+    }
+    const existingAppends = this.pendingAppends.get(key);
+    if (existingAppends) {
+      for (const append of existingAppends) {
+        this.pendingBytes -= append.length;
+      }
+      this.pendingAppends.delete(key);
+    }
+    await this.backend.delete(key);
+  }
+  async read(key) {
+    const pending = this.pendingWrites.get(key);
+    if (pending) {
+      const buffer = pending.data.buffer.slice(pending.data.byteOffset, pending.data.byteOffset + pending.data.length);
+      return buffer;
+    }
+    const appends = this.pendingAppends.get(key);
+    if (appends && appends.length > 0) {
+      const existing = await this.backend.read(key);
+      const existingBytes = existing ? new Uint8Array(existing) : new Uint8Array(0);
+      let totalSize = existingBytes.length;
+      for (const append of appends) {
+        totalSize += append.length;
+      }
+      const result = new Uint8Array(totalSize);
+      result.set(existingBytes);
+      let offset = existingBytes.length;
+      for (const append of appends) {
+        result.set(append, offset);
+        offset += append.length;
+      }
+      return result.buffer;
+    }
+    return this.backend.read(key);
+  }
+  async checkThresholds() {
+    const totalWrites = this.pendingWrites.size + this.pendingAppends.size;
+    if (totalWrites >= this.maxPendingWrites || this.pendingBytes >= this.maxPendingBytes) {
+      await this.flush();
+    }
+  }
+  async flush() {
+    if (this.isFlushing && this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
+    if (this.pendingWrites.size === 0 && this.pendingAppends.size === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    this.flushPromise = this.doFlush();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.isFlushing = false;
+      this.flushPromise = null;
+    }
+  }
+  async doFlush() {
+    const writes = Array.from(this.pendingWrites.values());
+    const appends = Array.from(this.pendingAppends.entries());
+    this.pendingWrites.clear();
+    this.pendingAppends.clear();
+    this.pendingBytes = 0;
+    const promises = [];
+    for (const write of writes) {
+      promises.push(this.backend.write(write.key, write.data));
+    }
+    for (const [key, chunks] of appends) {
+      let totalSize = 0;
+      for (const chunk of chunks) {
+        totalSize += chunk.length;
+      }
+      const combined = new Uint8Array(totalSize);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+      }
+      promises.push(this.backend.append(key, combined));
+    }
+    await Promise.all(promises);
+  }
+  getStats() {
+    return {
+      pendingWrites: this.pendingWrites.size,
+      pendingAppends: this.pendingAppends.size,
+      pendingBytes: this.pendingBytes,
+      maxPendingWrites: this.maxPendingWrites,
+      maxPendingBytes: this.maxPendingBytes
+    };
+  }
+  hasPendingWrites() {
+    return this.pendingWrites.size > 0 || this.pendingAppends.size > 0;
+  }
+  startAutoFlush() {
+    if (this.flushTimer)
+      return;
+    this.flushTimer = setInterval(async () => {
+      if (this.hasPendingWrites()) {
+        await this.flush();
+      }
+    }, this.autoFlushInterval);
+  }
+  stopAutoFlush() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  async close() {
+    this.stopAutoFlush();
+    await this.flush();
+  }
+  getBackend() {
+    return this.backend;
+  }
+}
+function createBatchWriter(backend, options) {
+  return new BatchWriter(backend, options);
+}
+// src/errors.ts
+class VectorDBError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "VectorDBError";
+    this.code = code;
+  }
+}
+
+class DimensionMismatchError extends VectorDBError {
+  expected;
+  actual;
+  constructor(expected, actual, context) {
+    const message = context ? `${context}: expected dimension ${expected}, got ${actual}` : `Dimension mismatch: expected ${expected}, got ${actual}`;
+    super(message, "DIMENSION_MISMATCH");
+    this.name = "DimensionMismatchError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+}
+
+class DuplicateVectorError extends VectorDBError {
+  ids;
+  constructor(ids) {
+    const message = ids.length === 1 ? `Vector with ID '${ids[0]}' already exists` : `Vectors with IDs already exist: ${ids.join(", ")}`;
+    super(message, "DUPLICATE_VECTOR");
+    this.name = "DuplicateVectorError";
+    this.ids = ids;
+  }
+}
+
+class CollectionNotFoundError extends VectorDBError {
+  collectionName;
+  constructor(collectionName) {
+    super(`Collection '${collectionName}' does not exist`, "COLLECTION_NOT_FOUND");
+    this.name = "CollectionNotFoundError";
+    this.collectionName = collectionName;
+  }
+}
+
+class CollectionExistsError extends VectorDBError {
+  collectionName;
+  constructor(collectionName) {
+    super(`Collection '${collectionName}' already exists`, "COLLECTION_EXISTS");
+    this.name = "CollectionExistsError";
+    this.collectionName = collectionName;
+  }
+}
+
+class StorageError extends VectorDBError {
+  operation;
+  path;
+  constructor(operation, message, path) {
+    super(`Storage ${operation} failed: ${message}`, "STORAGE_ERROR");
+    this.name = "StorageError";
+    this.operation = operation;
+    this.path = path;
+  }
+}
+
+class QuantizationError extends VectorDBError {
+  constructor(message) {
+    super(message, "QUANTIZATION_ERROR");
+    this.name = "QuantizationError";
+  }
+}
+
+class VectorNotFoundError extends VectorDBError {
+  vectorId;
+  constructor(vectorId) {
+    super(`Vector '${vectorId}' not found`, "VECTOR_NOT_FOUND");
+    this.name = "VectorNotFoundError";
+    this.vectorId = vectorId;
+  }
+}
+export {
+  normalizeInPlace,
+  l2SquaredInt8,
+  l2SquaredFast,
+  isStorageTypeAvailable,
+  getRecommendedStorageType,
+  getRecommendedPreset,
+  getRAGPreset,
+  getPreset,
+  encodeVarint,
+  dotProductInt8,
+  dotProductFast,
+  deltaEncodedSize,
+  deltaEncodeNeighbors,
+  deltaDecodeNeighbors,
+  decodeVarint,
+  createStorageBackend,
+  createBatchWriter,
+  cosineDistanceInt8,
+  cosineDistanceFast,
+  WriteAheadLog,
+  WALOperationType,
+  VectorNotFoundError,
+  VectorDBError,
+  VectorDB,
+  StorageError,
+  ScalarQuantizer,
+  QuantizedVectorStore,
+  QuantizationError,
+  PRESET_VERY_HIGH_DIM,
+  PRESET_SMALL_DATASET,
+  PRESET_MEDIUM_DIM,
+  PRESET_MAX_RECALL,
+  PRESET_LOW_LATENCY,
+  PRESET_LOW_DIM,
+  PRESET_LARGE_DATASET,
+  PRESET_HIGH_DIM,
+  PRESETS,
+  OPFSBackend,
+  MemoryBackend,
+  MaxBinaryHeap,
+  JsDistanceBackend,
+  HNSWIndex,
+  DuplicateVectorError,
+  DimensionMismatchError,
+  CollectionNotFoundError,
+  CollectionExistsError,
+  Collection,
+  BunStorageBackend,
+  BinaryHeap,
+  BatchWriter
+};