eigen-db 4.3.0 → 5.0.0

package/dist/eigen-db.js

@@ -1,9 +1,9 @@
-class k extends Error {
+class x extends Error {
   constructor(e) {
     super(`Capacity exceeded. Max vectors for this dimension size is ~${e}.`), this.name = "VectorCapacityExceededError";
   }
 }
-class _ {
+class N {
   dirHandle = null;
   dirName;
   constructor(e) {
@@ -25,7 +25,7 @@ class _ {
     }
   }
   async append(e, t) {
-    const s = await (await this.getDir()).getFileHandle(e, { create: !0 }), n = await s.createWritable({ keepExistingData: !0 }), i = await s.getFile();
+    const r = await (await this.getDir()).getFileHandle(e, { create: !0 }), n = await r.createWritable({ keepExistingData: !0 }), i = await r.getFile();
     await n.seek(i.size), await n.write(t), await n.close();
   }
   async write(e, t) {
@@ -36,16 +36,16 @@ class _ {
     await (await navigator.storage.getDirectory()).removeEntry(this.dirName, { recursive: !0 }), this.dirHandle = null;
   }
 }
-class v {
+class U {
   files = /* @__PURE__ */ new Map();
   async readAll(e) {
     const t = this.files.get(e);
     if (!t || t.length === 0) return new Uint8Array(0);
-    const r = t.reduce((i, a) => i + a.byteLength, 0), s = new Uint8Array(r);
+    const s = t.reduce((i, a) => i + a.byteLength, 0), r = new Uint8Array(s);
     let n = 0;
     for (const i of t)
-      s.set(i, n), n += i.byteLength;
-    return s;
+      r.set(i, n), n += i.byteLength;
+    return r;
   }
   async append(e, t) {
     this.files.has(e) || this.files.set(e, []), this.files.get(e).push(new Uint8Array(t));
@@ -57,46 +57,46 @@ class v {
     this.files.clear();
   }
 }
-function S(c) {
+function T(o) {
   let e = 0;
-  for (let s = 0; s < c.length; s++)
-    e += c[s] * c[s];
+  for (let r = 0; r < o.length; r++)
+    e += o[r] * o[r];
   const t = Math.sqrt(e);
   if (t === 0) return;
-  const r = 1 / t;
-  for (let s = 0; s < c.length; s++)
-    c[s] *= r;
+  const s = 1 / t;
+  for (let r = 0; r < o.length; r++)
+    o[r] *= s;
 }
-function O(c, e, t, r, s) {
-  for (let n = 0; n < r; n++) {
+function Q(o, e, t, s, r) {
+  for (let n = 0; n < s; n++) {
     let i = 0;
-    const a = n * s;
-    for (let o = 0; o < s; o++)
-      i += c[o] * e[a + o];
+    const a = n * r;
+    for (let c = 0; c < r; c++)
+      i += o[c] * e[a + c];
     t[n] = i;
   }
 }
-const U = new TextEncoder(), x = new TextDecoder();
-function d(c) {
-  const e = c.map((a) => U.encode(a)), t = e.reduce((a, o) => a + 4 + o.byteLength, 0), r = new ArrayBuffer(t), s = new DataView(r), n = new Uint8Array(r);
+const V = new TextEncoder(), _ = new TextDecoder();
+function b(o) {
+  const e = o.map((a) => V.encode(a)), t = e.reduce((a, c) => a + 4 + c.byteLength, 0), s = new ArrayBuffer(t), r = new DataView(s), n = new Uint8Array(s);
   let i = 0;
   for (const a of e)
-    s.setUint32(i, a.byteLength, !0), i += 4, n.set(a, i), i += a.byteLength;
+    r.setUint32(i, a.byteLength, !0), i += 4, n.set(a, i), i += a.byteLength;
   return n;
 }
-function g(c) {
-  const e = [], t = new DataView(c.buffer, c.byteOffset, c.byteLength);
-  let r = 0;
-  for (; r < c.byteLength; ) {
-    const s = t.getUint32(r, !0);
-    r += 4;
-    const n = x.decode(c.subarray(r, r + s));
-    e.push(n), r += s;
+function C(o) {
+  const e = [], t = new DataView(o.buffer, o.byteOffset, o.byteLength);
+  let s = 0;
+  for (; s < o.byteLength; ) {
+    const r = t.getUint32(s, !0);
+    s += 4;
+    const n = _.decode(o.subarray(s, s + r));
+    e.push(n), s += r;
   }
   return e;
 }
-const m = 65536, w = 65536;
-class Q {
+const m = 65536, E = 65536;
+class D {
   memory;
   dimensions;
   queryOffset;
@@ -104,9 +104,9 @@ class Q {
   _vectorCount;
   constructor(e, t = 0) {
     this.dimensions = e, this.queryOffset = 0;
-    const r = e * 4;
-    this.dbOffset = Math.ceil(r / m) * m;
-    const s = t * e * 4, n = this.dbOffset + s, i = Math.max(1, Math.ceil(n / m));
+    const s = e * 4;
+    this.dbOffset = Math.ceil(s / m) * m;
+    const r = t * e * 4, n = this.dbOffset + r, i = Math.max(1, Math.ceil(n / m));
     this.memory = new WebAssembly.Memory({ initial: i }), this._vectorCount = t;
   }
   /** Current number of vectors stored */
@@ -126,7 +126,7 @@ class Q {
    * Accounts for query buffer, DB space, and scores buffer.
    */
   get maxVectors() {
-    const e = w * m - this.dbOffset, t = this.dimensions * 4 + 4;
+    const e = E * m - this.dbOffset, t = this.dimensions * 4 + 4;
     return Math.floor(e / t);
   }
   /**
@@ -134,10 +134,10 @@ class Q {
    * Calls memory.grow() if needed.
    */
   ensureCapacity(e) {
-    const t = this._vectorCount + e, r = this.dbOffset + t * this.dimensions * 4 + t * 4, s = this.memory.buffer.byteLength;
-    if (r > s) {
-      const n = Math.ceil((r - s) / m);
-      if (s / m + n > w)
+    const t = this._vectorCount + e, s = this.dbOffset + t * this.dimensions * 4 + t * 4, r = this.memory.buffer.byteLength;
+    if (s > r) {
+      const n = Math.ceil((s - r) / m);
+      if (r / m + n > E)
         throw new Error("WASM memory limit exceeded");
       this.memory.grow(n);
     }
@@ -154,9 +154,9 @@ class Q {
    */
   appendVectors(e) {
     const t = this.dbOffset + this._vectorCount * this.dimensions * 4;
-    let r = t;
-    for (const s of e)
-      new Float32Array(this.memory.buffer, r, this.dimensions).set(s), r += this.dimensions * 4;
+    let s = t;
+    for (const r of e)
+      new Float32Array(this.memory.buffer, s, this.dimensions).set(r), s += this.dimensions * 4;
     return this._vectorCount += e.length, t;
   }
   /**
@@ -183,8 +183,8 @@ class Q {
    * Write a vector to a specific slot in the database region.
    */
   writeVector(e, t) {
-    const r = this.dbOffset + e * this.dimensions * 4;
-    new Float32Array(this.memory.buffer, r, this.dimensions).set(t);
+    const s = this.dbOffset + e * this.dimensions * 4;
+    new Float32Array(this.memory.buffer, s, this.dimensions).set(t);
   }
   /**
    * Reset the vector count to zero, logically clearing the database.
@@ -201,59 +201,62 @@ class Q {
     this._vectorCount = e;
   }
 }
-function D(c, e, t, r) {
-  const s = c.length;
-  if (s === 0) return [];
-  const n = new Uint32Array(s);
-  for (let o = 0; o < s; o++) n[o] = o;
-  n.sort((o, h) => c[h] - c[o]);
-  const i = Math.min(t, s), a = [];
-  for (let o = 0; o < i; o++) {
-    const h = n[o], f = c[h];
-    if (r !== void 0 && f < r) break;
-    a.push({ key: e(h), similarity: f });
-  }
-  return a;
+function p(o, e, t) {
+  return !(e !== void 0 && o < e || t !== void 0 && o > t);
 }
-function L(c, e, t, r) {
-  const s = c.length;
-  if (s === 0) return [];
-  const n = new Uint32Array(s);
-  for (let a = 0; a < s; a++) n[a] = a;
-  n.sort((a, o) => c[o] - c[a]);
-  const i = Math.min(t, s);
-  return {
+function L(o, e, t) {
+  const { limit: s, order: r, minSimilarity: n, maxSimilarity: i } = t, a = o.length;
+  if (a === 0) return [];
+  const c = new Uint32Array(a);
+  for (let l = 0; l < a; l++) c[l] = l;
+  r === "ascend" ? c.sort((l, y) => o[l] - o[y]) : c.sort((l, y) => o[y] - o[l]);
+  const A = Math.min(s, a), h = [];
+  for (let l = 0; l < a && h.length < A; l++) {
+    const y = c[l], f = o[y];
+    p(f, n, i) && h.push({ key: e(y), similarity: f });
+  }
+  return h;
+}
+function F(o, e, t) {
+  const { limit: s, order: r, minSimilarity: n, maxSimilarity: i } = t, a = o.length;
+  if (a === 0) return [];
+  const c = new Uint32Array(a);
+  for (let A = 0; A < a; A++) c[A] = A;
+  return r === "ascend" ? c.sort((A, h) => o[A] - o[h]) : c.sort((A, h) => o[h] - o[A]), {
     [Symbol.iterator]() {
-      let a = 0;
+      let A = 0, h = 0;
       return {
         next() {
-          if (a >= i) return { done: !0, value: void 0 };
-          const o = n[a++], h = c[o];
-          return r !== void 0 && h < r ? { done: !0, value: void 0 } : {
-            done: !1,
-            value: { key: e(o), similarity: h }
-          };
+          for (; A < a && h < s; ) {
+            const l = c[A++], y = o[l];
+            if (p(y, n, i))
+              return h++, {
+                done: !1,
+                value: { key: e(l), similarity: y }
+              };
+          }
+          return { done: !0, value: void 0 };
         }
       };
     }
   };
 }
-const V = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKpgQCrQIFAX8BewN9AXsCf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQkgAyAJ/QAEACAJ/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEAkADQCACIAFPDQEgACACQQJ0aiEJIAQgCSoCACAJKgIAlJIhBCACQQFqIQIMAAsLIASRIQUgBUMAAAAAWwRADwtDAACAPyAFlSEGIAb9EyEHQQAhAgJAA0AgAiAITw0BIAAgAkECdGohCSAJIAn9AAQAIAf95gH9CwQAIAJBBGohAgwACwsCQANAIAIgAU8NASAAIAJBAnRqIQkgCSAJKgIAIAaUOAIAIAJBAWohAgwACwsL9AEEAn8BewF9BX8gBEF8cSEKIARBAnQhDUEAIQUCQANAIAUgA08NASABIAUgDWxqIQn9DAAAAAAAAAAAAAAAAAAAAAAhB0EAIQYCQANAIAYgCk8NASAAIAZBAnRqIQsgCSAGQQJ0aiEMIAcgC/0ABAAgDP0ABAD95gH95AEhByAGQQRqIQYMAAsLIAf9HwAgB/0fAZIgB/0fAiAH/R8DkpIhCAJAA0AgBiAETw0BIAAgBkECdGohCyAJIAZBAnRqIQwgCCALKgIAIAwqAgCUkiEIIAZBAWohBgwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
-function T() {
-  const c = atob(V), e = new Uint8Array(c.length);
-  for (let t = 0; t < c.length; t++)
-    e[t] = c.charCodeAt(t);
+const z = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKpgQCrQIFAX8BewN9AXsCf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQkgAyAJ/QAEACAJ/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEAkADQCACIAFPDQEgACACQQJ0aiEJIAQgCSoCACAJKgIAlJIhBCACQQFqIQIMAAsLIASRIQUgBUMAAAAAWwRADwtDAACAPyAFlSEGIAb9EyEHQQAhAgJAA0AgAiAITw0BIAAgAkECdGohCSAJIAn9AAQAIAf95gH9CwQAIAJBBGohAgwACwsCQANAIAIgAU8NASAAIAJBAnRqIQkgCSAJKgIAIAaUOAIAIAJBAWohAgwACwsL9AEEAn8BewF9BX8gBEF8cSEKIARBAnQhDUEAIQUCQANAIAUgA08NASABIAUgDWxqIQn9DAAAAAAAAAAAAAAAAAAAAAAhB0EAIQYCQANAIAYgCk8NASAAIAZBAnRqIQsgCSAGQQJ0aiEMIAcgC/0ABAAgDP0ABAD95gH95AEhByAGQQRqIQYMAAsLIAf9HwAgB/0fAZIgB/0fAiAH/R8DkpIhCAJAA0AgBiAETw0BIAAgBkECdGohCyAJIAZBAnRqIQwgCCALKgIAIAwqAgCUkiEIIAZBAWohBgwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
+function q() {
+  const o = atob(z), e = new Uint8Array(o.length);
+  for (let t = 0; t < o.length; t++)
+    e[t] = o.charCodeAt(t);
   return e;
 }
-async function F(c, e) {
+async function R(o, e) {
   const t = { env: { memory: e } };
-  return (await WebAssembly.instantiate(c, t)).instance.exports;
+  return (await WebAssembly.instantiate(o, t)).instance.exports;
 }
-const b = "vectors.bin", E = "keys.bin", C = 1111770949, u = 1, I = 24, z = 65536;
-class M {
+const I = "vectors.bin", M = "keys.bin", S = 1111770949, d = 1, B = 24, H = 65536;
+class k {
   memoryManager;
   storage;
-  dimensions;
+  _dimensions;
   shouldNormalize;
   wasmExports;
   /** Maps key to its slot index in the vector array */
@@ -262,46 +265,98 @@ class M {
   slotToKey;
   /** Whether this instance has been closed */
   closed = !1;
-  constructor(e, t, r, s, n, i, a) {
-    this.memoryManager = e, this.storage = t, this.dimensions = r, this.shouldNormalize = s, this.wasmExports = n, this.keyToSlot = i, this.slotToKey = a;
+  constructor(e, t, s, r, n, i, a) {
+    this.memoryManager = e, this.storage = t, this._dimensions = s, this.shouldNormalize = r, this.wasmExports = n, this.keyToSlot = i, this.slotToKey = a;
   }
   static async open(e) {
-    const t = e.storage ?? new v(), r = e.normalize !== !1, [s, n] = await Promise.all([t.readAll(b), t.readAll(E)]), i = n.byteLength > 0 ? g(n) : [], a = s.byteLength / (e.dimensions * 4), o = /* @__PURE__ */ new Map(), h = [];
-    for (let A = 0; A < i.length; A++)
-      o.set(i[A], A), h[A] = i[A];
-    const f = new Q(e.dimensions, a);
-    s.byteLength > 0 && f.loadVectorBytes(s, a);
+    const t = e.storage ?? new U(), s = e.normalize !== !1, [r, n] = await Promise.all([t.readAll(I), t.readAll(M)]), i = n.byteLength > 0 ? C(n) : [], a = r.byteLength / (e.dimensions * 4), c = /* @__PURE__ */ new Map(), A = [];
+    for (let f = 0; f < i.length; f++)
+      c.set(i[f], f), A[f] = i[f];
+    const h = new D(e.dimensions, a);
+    r.byteLength > 0 && h.loadVectorBytes(r, a);
     let l = null;
-    const y = e.wasmBinary !== void 0 ? e.wasmBinary : T();
+    const y = e.wasmBinary !== void 0 ? e.wasmBinary : q();
     if (y !== null)
       try {
-        l = await F(y, f.memory);
+        l = await R(y, h.memory);
       } catch {
       }
-    return new M(f, t, e.dimensions, r, l, o, h);
+    return new k(h, t, e.dimensions, s, l, c, A);
   }
   /** Total number of key-value pairs in the database */
   get size() {
     return this.keyToSlot.size;
   }
+  /** Number of dimensions per vector */
+  get dimensions() {
+    return this._dimensions;
+  }
+  /**
+   * Check whether a key exists in the database.
+   * Uses the internal key-to-slot map for O(1) lookup.
+   */
+  has(e) {
+    return this.assertOpen(), this.keyToSlot.has(e);
+  }
+  /**
+   * Delete an entry by key. Returns true if the key existed, false otherwise.
+   * Uses swap-and-pop to avoid gaps in the underlying vector array.
+   */
+  delete(e) {
+    this.assertOpen();
+    const t = this.keyToSlot.get(e);
+    if (t === void 0) return !1;
+    const s = this.memoryManager.vectorCount - 1;
+    if (t !== s) {
+      const r = new Float32Array(this.memoryManager.readVector(s));
+      this.memoryManager.writeVector(t, r);
+      const n = this.slotToKey[s];
+      this.keyToSlot.set(n, t), this.slotToKey[t] = n;
+    }
+    return this.keyToSlot.delete(e), this.slotToKey.length = s, this.memoryManager.setVectorCount(s), !0;
+  }
+  /**
+   * Returns an iterable of all keys in the database.
+   */
+  keys() {
+    return this.assertOpen(), this.keyToSlot.keys();
+  }
+  /**
+   * Returns an iterable of [key, value] pairs.
+   * Values are returned as plain number array copies.
+   */
+  entries() {
+    this.assertOpen();
+    const e = this.keyToSlot, t = this.memoryManager;
+    return (function* () {
+      for (const [s, r] of e)
+        yield [s, Array.from(t.readVector(r))];
+    })();
+  }
+  /**
+   * Implements the iterable protocol. Same as entries().
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
   /**
    * Set a key-value pair. If the key already exists, its vector is overwritten (last-write-wins).
    * The value is a number[] or Float32Array of length equal to the configured dimensions.
    */
-  set(e, t, r) {
-    if (this.assertOpen(), t.length !== this.dimensions)
-      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${t.length}`);
-    const s = new Float32Array(t);
-    (r?.normalize ?? this.shouldNormalize) && this.normalizeVector(s);
+  set(e, t, s) {
+    if (this.assertOpen(), t.length !== this._dimensions)
+      throw new Error(`Vector dimension mismatch: expected ${this._dimensions}, got ${t.length}`);
+    const r = new Float32Array(t);
+    (s?.normalize ?? this.shouldNormalize) && this.normalizeVector(r);
     const i = this.keyToSlot.get(e);
     if (i !== void 0)
-      this.memoryManager.writeVector(i, s);
+      this.memoryManager.writeVector(i, r);
     else {
       if (this.memoryManager.vectorCount + 1 > this.memoryManager.maxVectors)
-        throw new k(this.memoryManager.maxVectors);
+        throw new x(this.memoryManager.maxVectors);
       this.memoryManager.ensureCapacity(1);
-      const o = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, o), this.slotToKey[o] = e;
+      const c = this.memoryManager.vectorCount;
+      this.memoryManager.appendVectors([r]), this.keyToSlot.set(e, c), this.slotToKey[c] = e;
     }
   }
   /**
@@ -318,8 +373,8 @@ class M {
    * Set multiple key-value pairs at once. Last-write-wins applies within the batch.
    */
   setMany(e) {
-    for (const [t, r] of e)
-      this.set(t, r);
+    for (const [t, s] of e)
+      this.set(t, s);
   }
   /**
    * Get vectors for multiple keys. Returns undefined for keys that don't exist.
@@ -329,53 +384,53 @@ class M {
   }
   query(e, t) {
     this.assertOpen();
-    const r = t?.topK ?? 1 / 0, s = t?.minSimilarity, n = t && "iterable" in t && t.iterable;
+    const s = t?.limit ?? 1 / 0, r = t?.order ?? "descend", n = t?.minSimilarity, i = t?.maxSimilarity, a = t && "iterable" in t && t.iterable;
     if (this.size === 0)
       return [];
-    if (e.length !== this.dimensions)
-      throw new Error(`Query vector dimension mismatch: expected ${this.dimensions}, got ${e.length}`);
-    const i = new Float32Array(e);
-    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(i), this.memoryManager.writeQuery(i), this.memoryManager.ensureCapacity(0);
-    const o = this.memoryManager.vectorCount, h = this.memoryManager.scoresOffset;
+    if (e.length !== this._dimensions)
+      throw new Error(`Query vector dimension mismatch: expected ${this._dimensions}, got ${e.length}`);
+    const c = new Float32Array(e);
+    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(c), this.memoryManager.writeQuery(c), this.memoryManager.ensureCapacity(0);
+    const h = this.memoryManager.vectorCount, l = this.memoryManager.scoresOffset;
     if (this.wasmExports)
       this.wasmExports.search_all(
         this.memoryManager.queryOffset,
         this.memoryManager.dbOffset,
+        l,
         h,
-        o,
-        this.dimensions
+        this._dimensions
       );
     else {
-      const A = new Float32Array(
+      const u = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.queryOffset,
-        this.dimensions
-      ), B = new Float32Array(
+        this._dimensions
+      ), O = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        o * this.dimensions
-      ), p = new Float32Array(this.memoryManager.memory.buffer, h, o);
-      O(A, B, p, o, this.dimensions);
+        h * this._dimensions
+      ), v = new Float32Array(this.memoryManager.memory.buffer, l, h);
+      Q(u, O, v, h, this._dimensions);
     }
-    const f = new Float32Array(this.memoryManager.readScores()), l = this.slotToKey, y = (A) => l[A];
-    return n ? L(f, y, r, s) : D(f, y, r, s);
+    const y = new Float32Array(this.memoryManager.readScores()), f = this.slotToKey, g = (u) => f[u], w = { limit: s, order: r, minSimilarity: n, maxSimilarity: i };
+    return a ? F(y, g, w) : L(y, g, w);
   }
   /**
    * Persist the current in-memory state to storage.
    */
   async flush() {
     this.assertOpen();
-    const e = this.memoryManager.vectorCount, t = new Uint8Array(e * this.dimensions * 4);
+    const e = this.memoryManager.vectorCount, t = new Uint8Array(e * this._dimensions * 4);
     if (e > 0) {
-      const s = new Uint8Array(
+      const r = new Uint8Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        e * this.dimensions * 4
+        e * this._dimensions * 4
       );
-      t.set(s);
+      t.set(r);
     }
-    const r = d(this.slotToKey);
-    await Promise.all([this.storage.write(b, t), this.storage.write(E, r)]);
+    const s = b(this.slotToKey);
+    await Promise.all([this.storage.write(I, t), this.storage.write(M, s)]);
   }
   /**
    * Flush data to storage and release the instance.
@@ -401,23 +456,23 @@ class M {
    */
   async export() {
     this.assertOpen();
-    const e = this.memoryManager.vectorCount, t = e * this.dimensions * 4, r = d(this.slotToKey), s = r.byteLength, n = new ArrayBuffer(I), i = new DataView(n);
-    i.setUint32(0, C, !0), i.setUint32(4, u, !0), i.setUint32(8, this.dimensions, !0), i.setUint32(12, e, !0), i.setUint32(16, t, !0), i.setUint32(20, s, !0);
+    const e = this.memoryManager.vectorCount, t = e * this._dimensions * 4, s = b(this.slotToKey), r = s.byteLength, n = new ArrayBuffer(B), i = new DataView(n);
+    i.setUint32(0, S, !0), i.setUint32(4, d, !0), i.setUint32(8, this._dimensions, !0), i.setUint32(12, e, !0), i.setUint32(16, t, !0), i.setUint32(20, r, !0);
     const a = this.memoryManager;
-    let o = "header", h = 0;
+    let c = "header", A = 0;
     return new ReadableStream({
-      pull(f) {
-        switch (o) {
+      pull(h) {
+        switch (c) {
           case "header":
-            f.enqueue(new Uint8Array(n)), o = t > 0 ? "vectors" : s > 0 ? "keys" : "done", o === "done" && f.close();
+            h.enqueue(new Uint8Array(n)), c = t > 0 ? "vectors" : r > 0 ? "keys" : "done", c === "done" && h.close();
             break;
           case "vectors": {
-            const l = t - h, y = Math.min(l, z), A = new Uint8Array(y);
-            A.set(new Uint8Array(a.memory.buffer, a.dbOffset + h, y)), f.enqueue(A), h += y, h >= t && (o = s > 0 ? "keys" : "done", o === "done" && f.close());
+            const l = t - A, y = Math.min(l, H), f = new Uint8Array(y);
+            f.set(new Uint8Array(a.memory.buffer, a.dbOffset + A, y)), h.enqueue(f), A += y, A >= t && (c = r > 0 ? "keys" : "done", c === "done" && h.close());
             break;
           }
           case "keys":
-            f.enqueue(r), o = "done", f.close();
+            h.enqueue(s), c = "done", h.close();
             break;
         }
       }
@@ -432,29 +487,29 @@ class M {
    */
   async import(e) {
     this.assertOpen();
-    const t = new q(e), r = await t.readExact(I), s = new DataView(r.buffer, r.byteOffset, r.byteLength);
-    if (s.getUint32(0, !0) !== C)
+    const t = new K(e), s = await t.readExact(B), r = new DataView(s.buffer, s.byteOffset, s.byteLength);
+    if (r.getUint32(0, !0) !== S)
       throw new Error("Invalid import data: unrecognized format");
-    const i = s.getUint32(4, !0);
-    if (i !== u)
-      throw new Error(`Unsupported import version: expected ${u}, got ${i}`);
-    const a = s.getUint32(8, !0);
-    if (a !== this.dimensions)
-      throw new Error(`Import dimension mismatch: expected ${this.dimensions}, got ${a}`);
-    const o = s.getUint32(12, !0), h = s.getUint32(16, !0), f = s.getUint32(20, !0);
-    if (this.keyToSlot.clear(), this.slotToKey.length = 0, this.memoryManager.reset(), o > 0) {
-      this.memoryManager.ensureCapacity(o);
+    const i = r.getUint32(4, !0);
+    if (i !== d)
+      throw new Error(`Unsupported import version: expected ${d}, got ${i}`);
+    const a = r.getUint32(8, !0);
+    if (a !== this._dimensions)
+      throw new Error(`Import dimension mismatch: expected ${this._dimensions}, got ${a}`);
+    const c = r.getUint32(12, !0), A = r.getUint32(16, !0), h = r.getUint32(20, !0);
+    if (this.keyToSlot.clear(), this.slotToKey.length = 0, this.memoryManager.reset(), c > 0) {
+      this.memoryManager.ensureCapacity(c);
       let l = 0;
-      await t.readChunked(h, (y) => {
+      await t.readChunked(A, (y) => {
         new Uint8Array(this.memoryManager.memory.buffer, this.memoryManager.dbOffset + l, y.byteLength).set(
           y
         ), l += y.byteLength;
-      }), this.memoryManager.setVectorCount(o);
+      }), this.memoryManager.setVectorCount(c);
     }
-    if (f > 0) {
-      const l = await t.readExact(f), y = g(l);
-      for (let A = 0; A < y.length; A++)
-        this.keyToSlot.set(y[A], A), this.slotToKey[A] = y[A];
+    if (h > 0) {
+      const l = await t.readExact(h), y = C(l);
+      for (let f = 0; f < y.length; f++)
+        this.keyToSlot.set(y[f], f), this.slotToKey[f] = y[f];
     }
     t.release();
   }
@@ -465,17 +520,17 @@ class M {
     if (this.wasmExports) {
       const t = this.memoryManager.queryOffset;
       new Float32Array(this.memoryManager.memory.buffer, t, e.length).set(e), this.wasmExports.normalize(t, e.length);
-      const r = new Float32Array(this.memoryManager.memory.buffer, t, e.length);
-      e.set(r);
+      const s = new Float32Array(this.memoryManager.memory.buffer, t, e.length);
+      e.set(s);
     } else
-      S(e);
+      T(e);
   }
   assertOpen() {
     if (this.closed)
       throw new Error("VectorDB instance has been closed");
   }
 }
-class q {
+class K {
   reader;
   buffer = new Uint8Array(0);
   constructor(e) {
@@ -489,32 +544,32 @@ class q {
       return this.buffer = this.buffer.subarray(e), i;
     }
     const t = [];
-    let r = this.buffer.byteLength;
-    for (r > 0 && (t.push(this.buffer), this.buffer = new Uint8Array(0)); r < e; ) {
+    let s = this.buffer.byteLength;
+    for (s > 0 && (t.push(this.buffer), this.buffer = new Uint8Array(0)); s < e; ) {
       const { done: i, value: a } = await this.reader.read();
       if (i) throw new Error("Invalid import data: unexpected end of stream");
-      t.push(a), r += a.byteLength;
+      t.push(a), s += a.byteLength;
     }
-    const s = new Uint8Array(r);
+    const r = new Uint8Array(s);
     let n = 0;
     for (const i of t)
-      s.set(i, n), n += i.byteLength;
-    return r > e ? (this.buffer = s.subarray(e), s.subarray(0, e)) : s;
+      r.set(i, n), n += i.byteLength;
+    return s > e ? (this.buffer = r.subarray(e), r.subarray(0, e)) : r;
   }
   /**
    * Read `totalBytes` from the stream in chunks, calling `onChunk` for each.
    * Avoids allocating a single large buffer for the full data.
    */
   async readChunked(e, t) {
-    let r = e;
+    let s = e;
     if (this.buffer.byteLength > 0) {
-      const s = Math.min(this.buffer.byteLength, r);
-      t(this.buffer.subarray(0, s)), r -= s, this.buffer = this.buffer.subarray(s);
+      const r = Math.min(this.buffer.byteLength, s);
+      t(this.buffer.subarray(0, r)), s -= r, this.buffer = this.buffer.subarray(r);
     }
-    for (; r > 0; ) {
-      const { done: s, value: n } = await this.reader.read();
-      if (s) throw new Error("Invalid import data: unexpected end of stream");
-      n.byteLength <= r ? (t(n), r -= n.byteLength) : (t(n.subarray(0, r)), this.buffer = n.slice(r), r = 0);
+    for (; s > 0; ) {
+      const { done: r, value: n } = await this.reader.read();
+      if (r) throw new Error("Invalid import data: unexpected end of stream");
+      n.byteLength <= s ? (t(n), s -= n.byteLength) : (t(n.subarray(0, s)), this.buffer = n.slice(s), s = 0);
     }
   }
   /** Release the stream reader lock. */
@@ -523,9 +578,9 @@ class q {
   }
 }
 export {
-  M as DB,
-  v as InMemoryStorageProvider,
-  _ as OPFSStorageProvider,
-  k as VectorCapacityExceededError
+  k as DB,
+  U as InMemoryStorageProvider,
+  N as OPFSStorageProvider,
+  x as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map