eigen-db 4.2.0 → 4.4.0

package/dist/eigen-db.js

@@ -3,7 +3,7 @@ class k extends Error {
     super(`Capacity exceeded. Max vectors for this dimension size is ~${e}.`), this.name = "VectorCapacityExceededError";
   }
 }
-class D {
+class K {
   dirHandle = null;
   dirName;
   constructor(e) {
@@ -18,34 +18,34 @@ class D {
   }
   async readAll(e) {
     try {
-      const r = await (await (await (await this.getDir()).getFileHandle(e)).getFile()).arrayBuffer();
-      return new Uint8Array(r);
+      const n = await (await (await (await this.getDir()).getFileHandle(e)).getFile()).arrayBuffer();
+      return new Uint8Array(n);
     } catch {
       return new Uint8Array(0);
     }
   }
   async append(e, t) {
-    const A = await (await this.getDir()).getFileHandle(e, { create: !0 }), r = await A.createWritable({ keepExistingData: !0 }), n = await A.getFile();
-    await r.seek(n.size), await r.write(t), await r.close();
+    const s = await (await this.getDir()).getFileHandle(e, { create: !0 }), n = await s.createWritable({ keepExistingData: !0 }), o = await s.getFile();
+    await n.seek(o.size), await n.write(t), await n.close();
   }
   async write(e, t) {
-    const r = await (await (await this.getDir()).getFileHandle(e, { create: !0 })).createWritable({ keepExistingData: !1 });
-    await r.write(t), await r.close();
+    const n = await (await (await this.getDir()).getFileHandle(e, { create: !0 })).createWritable({ keepExistingData: !1 });
+    await n.write(t), await n.close();
   }
   async destroy() {
     await (await navigator.storage.getDirectory()).removeEntry(this.dirName, { recursive: !0 }), this.dirHandle = null;
   }
 }
-class F {
+class S {
   files = /* @__PURE__ */ new Map();
   async readAll(e) {
     const t = this.files.get(e);
     if (!t || t.length === 0) return new Uint8Array(0);
-    const s = t.reduce((n, o) => n + o.byteLength, 0), A = new Uint8Array(s);
-    let r = 0;
-    for (const n of t)
-      A.set(n, r), r += n.byteLength;
-    return A;
+    const r = t.reduce((o, a) => o + a.byteLength, 0), s = new Uint8Array(r);
+    let n = 0;
+    for (const o of t)
+      s.set(o, n), n += o.byteLength;
+    return s;
   }
   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 F {
     this.files.clear();
   }
 }
-function S(a) {
+function v(c) {
   let e = 0;
-  for (let A = 0; A < a.length; A++)
-    e += a[A] * a[A];
+  for (let s = 0; s < c.length; s++)
+    e += c[s] * c[s];
   const t = Math.sqrt(e);
   if (t === 0) return;
-  const s = 1 / t;
-  for (let A = 0; A < a.length; A++)
-    a[A] *= s;
+  const r = 1 / t;
+  for (let s = 0; s < c.length; s++)
+    c[s] *= r;
 }
-function v(a, e, t, s, A) {
-  for (let r = 0; r < s; r++) {
-    let n = 0;
-    const o = r * A;
-    for (let i = 0; i < A; i++)
-      n += a[i] * e[o + i];
-    t[r] = n;
+function O(c, e, t, r, s) {
+  for (let n = 0; n < r; n++) {
+    let o = 0;
+    const a = n * s;
+    for (let i = 0; i < s; i++)
+      o += c[i] * e[a + i];
+    t[n] = o;
   }
 }
-const p = new TextEncoder(), U = new TextDecoder();
-function u(a) {
-  const e = a.map((o) => p.encode(o)), t = e.reduce((o, i) => o + 4 + i.byteLength, 0), s = new ArrayBuffer(t), A = new DataView(s), r = new Uint8Array(s);
-  let n = 0;
-  for (const o of e)
-    A.setUint32(n, o.byteLength, !0), n += 4, r.set(o, n), n += o.byteLength;
-  return r;
+const U = new TextEncoder(), x = new TextDecoder();
+function d(c) {
+  const e = c.map((a) => U.encode(a)), t = e.reduce((a, i) => a + 4 + i.byteLength, 0), r = new ArrayBuffer(t), s = new DataView(r), n = new Uint8Array(r);
+  let o = 0;
+  for (const a of e)
+    s.setUint32(o, a.byteLength, !0), o += 4, n.set(a, o), o += a.byteLength;
+  return n;
 }
-function w(a) {
-  const e = [], t = new DataView(a.buffer, a.byteOffset, a.byteLength);
-  let s = 0;
-  for (; s < a.byteLength; ) {
-    const A = t.getUint32(s, !0);
-    s += 4;
-    const r = U.decode(a.subarray(s, s + A));
-    e.push(r), s += A;
+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;
   }
   return e;
 }
-const l = 65536, I = 65536;
-class L {
+const m = 65536, w = 65536;
+class T {
   memory;
   dimensions;
   queryOffset;
@@ -104,10 +104,10 @@ class L {
   _vectorCount;
   constructor(e, t = 0) {
     this.dimensions = e, this.queryOffset = 0;
-    const s = e * 4;
-    this.dbOffset = Math.ceil(s / l) * l;
-    const A = t * e * 4, r = this.dbOffset + A, n = Math.max(1, Math.ceil(r / l));
-    this.memory = new WebAssembly.Memory({ initial: n }), this._vectorCount = t;
+    const r = e * 4;
+    this.dbOffset = Math.ceil(r / m) * m;
+    const s = t * e * 4, n = this.dbOffset + s, o = Math.max(1, Math.ceil(n / m));
+    this.memory = new WebAssembly.Memory({ initial: o }), this._vectorCount = t;
   }
   /** Current number of vectors stored */
   get vectorCount() {
@@ -126,7 +126,7 @@ class L {
    * Accounts for query buffer, DB space, and scores buffer.
    */
   get maxVectors() {
-    const e = I * l - this.dbOffset, t = this.dimensions * 4 + 4;
+    const e = w * m - this.dbOffset, t = this.dimensions * 4 + 4;
     return Math.floor(e / t);
   }
   /**
@@ -134,12 +134,12 @@ class L {
    * Calls memory.grow() if needed.
    */
   ensureCapacity(e) {
-    const t = this._vectorCount + e, s = this.dbOffset + t * this.dimensions * 4 + t * 4, A = this.memory.buffer.byteLength;
-    if (s > A) {
-      const r = Math.ceil((s - A) / l);
-      if (A / l + r > I)
+    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)
         throw new Error("WASM memory limit exceeded");
-      this.memory.grow(r);
+      this.memory.grow(n);
     }
   }
   /**
@@ -154,9 +154,9 @@ class L {
    */
   appendVectors(e) {
     const t = this.dbOffset + this._vectorCount * this.dimensions * 4;
-    let s = t;
-    for (const A of e)
-      new Float32Array(this.memory.buffer, s, this.dimensions).set(A), s += 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;
     return this._vectorCount += e.length, t;
   }
   /**
@@ -183,8 +183,8 @@ class L {
    * Write a vector to a specific slot in the database region.
    */
   writeVector(e, t) {
-    const s = this.dbOffset + e * this.dimensions * 4;
-    new Float32Array(this.memory.buffer, s, this.dimensions).set(t);
+    const r = this.dbOffset + e * this.dimensions * 4;
+    new Float32Array(this.memory.buffer, r, this.dimensions).set(t);
   }
   /**
    * Reset the vector count to zero, logically clearing the database.
@@ -201,59 +201,59 @@ class L {
     this._vectorCount = e;
   }
 }
-function x(a, e, t, s) {
-  const A = a.length;
-  if (A === 0) return [];
-  const r = new Uint32Array(A);
-  for (let i = 0; i < A; i++) r[i] = i;
-  r.sort((i, c) => a[c] - a[i]);
-  const n = Math.min(t, A), o = [];
-  for (let i = 0; i < n; i++) {
-    const c = r[i], h = a[c];
-    if (s !== void 0 && h < s) break;
-    o.push({ key: e(c), similarity: h });
-  }
-  return o;
+function Q(c, e, t, r) {
+  const s = c.length;
+  if (s === 0) return [];
+  const n = new Uint32Array(s);
+  for (let i = 0; i < s; i++) n[i] = i;
+  n.sort((i, h) => c[h] - c[i]);
+  const o = Math.min(t, s), a = [];
+  for (let i = 0; i < o; i++) {
+    const h = n[i], y = c[h];
+    if (r !== void 0 && y < r) break;
+    a.push({ key: e(h), similarity: y });
+  }
+  return a;
 }
-function O(a, e, t, s) {
-  const A = a.length;
-  if (A === 0) return [];
-  const r = new Uint32Array(A);
-  for (let o = 0; o < A; o++) r[o] = o;
-  r.sort((o, i) => a[i] - a[o]);
-  const n = Math.min(t, A);
+function V(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, i) => c[i] - c[a]);
+  const o = Math.min(t, s);
   return {
     [Symbol.iterator]() {
-      let o = 0;
+      let a = 0;
       return {
         next() {
-          if (o >= n) return { done: !0, value: void 0 };
-          const i = r[o++], c = a[i];
-          return s !== void 0 && c < s ? { done: !0, value: void 0 } : {
+          if (a >= o) return { done: !0, value: void 0 };
+          const i = n[a++], h = c[i];
+          return r !== void 0 && h < r ? { done: !0, value: void 0 } : {
             done: !1,
-            value: { key: e(i), similarity: c }
+            value: { key: e(i), similarity: h }
           };
         }
       };
     }
   };
 }
-const G = "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";
-function R() {
-  const a = atob(G), e = new Uint8Array(a.length);
-  for (let t = 0; t < a.length; t++)
-    e[t] = a.charCodeAt(t);
+const _ = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKpgQCrQIFAX8BewN9AXsCf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQkgAyAJ/QAEACAJ/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEAkADQCACIAFPDQEgACACQQJ0aiEJIAQgCSoCACAJKgIAlJIhBCACQQFqIQIMAAsLIASRIQUgBUMAAAAAWwRADwtDAACAPyAFlSEGIAb9EyEHQQAhAgJAA0AgAiAITw0BIAAgAkECdGohCSAJIAn9AAQAIAf95gH9CwQAIAJBBGohAgwACwsCQANAIAIgAU8NASAAIAJBAnRqIQkgCSAJKgIAIAaUOAIAIAJBAWohAgwACwsL9AEEAn8BewF9BX8gBEF8cSEKIARBAnQhDUEAIQUCQANAIAUgA08NASABIAUgDWxqIQn9DAAAAAAAAAAAAAAAAAAAAAAhB0EAIQYCQANAIAYgCk8NASAAIAZBAnRqIQsgCSAGQQJ0aiEMIAcgC/0ABAAgDP0ABAD95gH95AEhByAGQQRqIQYMAAsLIAf9HwAgB/0fAZIgB/0fAiAH/R8DkpIhCAJAA0AgBiAETw0BIAAgBkECdGohCyAJIAZBAnRqIQwgCCALKgIAIAwqAgCUkiEIIAZBAWohBgwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
+function D() {
+  const c = atob(_), e = new Uint8Array(c.length);
+  for (let t = 0; t < c.length; t++)
+    e[t] = c.charCodeAt(t);
   return e;
 }
-async function T(a, e) {
+async function L(c, e) {
   const t = { env: { memory: e } };
-  return (await WebAssembly.instantiate(a, t)).instance.exports;
+  return (await WebAssembly.instantiate(c, t)).instance.exports;
 }
-const B = "vectors.bin", Q = "keys.bin", E = 1111770949, d = 1, C = 24, H = 65536;
-class b {
+const b = "vectors.bin", C = "keys.bin", E = 1111770949, u = 1, M = 24, F = 65536;
+class I {
   memoryManager;
   storage;
-  dimensions;
+  _dimensions;
   shouldNormalize;
   wasmExports;
   /** Maps key to its slot index in the vector array */
@@ -262,46 +262,98 @@ class b {
   slotToKey;
   /** Whether this instance has been closed */
   closed = !1;
-  constructor(e, t, s, A, r, n, o) {
-    this.memoryManager = e, this.storage = t, this.dimensions = s, this.shouldNormalize = A, this.wasmExports = r, this.keyToSlot = n, this.slotToKey = o;
+  constructor(e, t, r, s, n, o, a) {
+    this.memoryManager = e, this.storage = t, this._dimensions = r, this.shouldNormalize = s, this.wasmExports = n, this.keyToSlot = o, this.slotToKey = a;
   }
   static async open(e) {
-    const t = e.name ?? "default", s = e.storage ?? new D(t), A = e.normalize !== !1, [r, n] = await Promise.all([s.readAll(B), s.readAll(Q)]), o = n.byteLength > 0 ? w(n) : [], i = r.byteLength / (e.dimensions * 4), c = /* @__PURE__ */ new Map(), h = [];
-    for (let m = 0; m < o.length; m++)
-      c.set(o[m], m), h[m] = o[m];
-    const g = new L(e.dimensions, i);
-    r.byteLength > 0 && g.loadVectorBytes(r, i);
-    let f = null;
-    const y = e.wasmBinary !== void 0 ? e.wasmBinary : R();
-    if (y !== null)
+    const t = e.storage ?? new S(), r = e.normalize !== !1, [s, n] = await Promise.all([t.readAll(b), t.readAll(C)]), o = n.byteLength > 0 ? g(n) : [], a = s.byteLength / (e.dimensions * 4), i = /* @__PURE__ */ new Map(), h = [];
+    for (let A = 0; A < o.length; A++)
+      i.set(o[A], A), h[A] = o[A];
+    const y = new T(e.dimensions, a);
+    s.byteLength > 0 && y.loadVectorBytes(s, a);
+    let l = null;
+    const f = e.wasmBinary !== void 0 ? e.wasmBinary : D();
+    if (f !== null)
       try {
-        f = await T(y, g.memory);
+        l = await L(f, y.memory);
       } catch {
       }
-    return new b(g, s, e.dimensions, A, f, c, h);
+    return new I(y, t, e.dimensions, r, l, i, h);
   }
   /** 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 r = this.memoryManager.vectorCount - 1;
+    if (t !== r) {
+      const s = new Float32Array(this.memoryManager.readVector(r));
+      this.memoryManager.writeVector(t, s);
+      const n = this.slotToKey[r];
+      this.keyToSlot.set(n, t), this.slotToKey[t] = n;
+    }
+    return this.keyToSlot.delete(e), this.slotToKey.length = r, this.memoryManager.setVectorCount(r), !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 [r, s] of e)
+        yield [r, Array.from(t.readVector(s))];
+    })();
+  }
+  /**
+   * 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, s) {
-    if (this.assertOpen(), t.length !== this.dimensions)
-      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${t.length}`);
-    const A = new Float32Array(t);
-    (s?.normalize ?? this.shouldNormalize) && this.normalizeVector(A);
-    const n = this.keyToSlot.get(e);
-    if (n !== void 0)
-      this.memoryManager.writeVector(n, A);
+  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);
+    const o = this.keyToSlot.get(e);
+    if (o !== void 0)
+      this.memoryManager.writeVector(o, s);
     else {
       if (this.memoryManager.vectorCount + 1 > this.memoryManager.maxVectors)
         throw new k(this.memoryManager.maxVectors);
       this.memoryManager.ensureCapacity(1);
       const i = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([A]), this.keyToSlot.set(e, i), this.slotToKey[i] = e;
+      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, i), this.slotToKey[i] = e;
     }
   }
   /**
@@ -318,8 +370,8 @@ class b {
    * Set multiple key-value pairs at once. Last-write-wins applies within the batch.
    */
   setMany(e) {
-    for (const [t, s] of e)
-      this.set(t, s);
+    for (const [t, r] of e)
+      this.set(t, r);
   }
   /**
    * Get vectors for multiple keys. Returns undefined for keys that don't exist.
@@ -329,53 +381,53 @@ class b {
   }
   query(e, t) {
     this.assertOpen();
-    const s = t?.topK ?? 1 / 0, A = t?.minSimilarity, r = t && "iterable" in t && t.iterable;
+    const r = t?.topK ?? 1 / 0, s = t?.minSimilarity, n = 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 n = new Float32Array(e);
-    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(n), this.memoryManager.writeQuery(n), this.memoryManager.ensureCapacity(0);
-    const i = this.memoryManager.vectorCount, c = this.memoryManager.scoresOffset;
+    if (e.length !== this._dimensions)
+      throw new Error(`Query vector dimension mismatch: expected ${this._dimensions}, got ${e.length}`);
+    const o = new Float32Array(e);
+    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(o), this.memoryManager.writeQuery(o), this.memoryManager.ensureCapacity(0);
+    const i = this.memoryManager.vectorCount, h = this.memoryManager.scoresOffset;
     if (this.wasmExports)
       this.wasmExports.search_all(
         this.memoryManager.queryOffset,
         this.memoryManager.dbOffset,
-        c,
+        h,
         i,
-        this.dimensions
+        this._dimensions
       );
     else {
-      const y = new Float32Array(
+      const A = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.queryOffset,
-        this.dimensions
-      ), m = new Float32Array(
+        this._dimensions
+      ), p = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        i * this.dimensions
-      ), M = new Float32Array(this.memoryManager.memory.buffer, c, i);
-      v(y, m, M, i, this.dimensions);
+        i * this._dimensions
+      ), B = new Float32Array(this.memoryManager.memory.buffer, h, i);
+      O(A, p, B, i, this._dimensions);
     }
-    const h = new Float32Array(this.memoryManager.readScores()), g = this.slotToKey, f = (y) => g[y];
-    return r ? O(h, f, s, A) : x(h, f, s, A);
+    const y = new Float32Array(this.memoryManager.readScores()), l = this.slotToKey, f = (A) => l[A];
+    return n ? V(y, f, r, s) : Q(y, f, r, s);
   }
   /**
    * 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 A = new Uint8Array(
+      const s = new Uint8Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        e * this.dimensions * 4
+        e * this._dimensions * 4
       );
-      t.set(A);
+      t.set(s);
     }
-    const s = u(this.slotToKey);
-    await Promise.all([this.storage.write(B, t), this.storage.write(Q, s)]);
+    const r = d(this.slotToKey);
+    await Promise.all([this.storage.write(b, t), this.storage.write(C, r)]);
   }
   /**
    * Flush data to storage and release the instance.
@@ -401,23 +453,23 @@ class b {
    */
   async export() {
     this.assertOpen();
-    const e = this.memoryManager.vectorCount, t = e * this.dimensions * 4, s = u(this.slotToKey), A = s.byteLength, r = new ArrayBuffer(C), n = new DataView(r);
-    n.setUint32(0, E, !0), n.setUint32(4, d, !0), n.setUint32(8, this.dimensions, !0), n.setUint32(12, e, !0), n.setUint32(16, t, !0), n.setUint32(20, A, !0);
-    const o = this.memoryManager;
-    let i = "header", c = 0;
+    const e = this.memoryManager.vectorCount, t = e * this._dimensions * 4, r = d(this.slotToKey), s = r.byteLength, n = new ArrayBuffer(M), o = new DataView(n);
+    o.setUint32(0, E, !0), o.setUint32(4, u, !0), o.setUint32(8, this._dimensions, !0), o.setUint32(12, e, !0), o.setUint32(16, t, !0), o.setUint32(20, s, !0);
+    const a = this.memoryManager;
+    let i = "header", h = 0;
     return new ReadableStream({
-      pull(h) {
+      pull(y) {
         switch (i) {
           case "header":
-            h.enqueue(new Uint8Array(r)), i = t > 0 ? "vectors" : A > 0 ? "keys" : "done", i === "done" && h.close();
+            y.enqueue(new Uint8Array(n)), i = t > 0 ? "vectors" : s > 0 ? "keys" : "done", i === "done" && y.close();
             break;
           case "vectors": {
-            const g = t - c, f = Math.min(g, H), y = new Uint8Array(f);
-            y.set(new Uint8Array(o.memory.buffer, o.dbOffset + c, f)), h.enqueue(y), c += f, c >= t && (i = A > 0 ? "keys" : "done", i === "done" && h.close());
+            const l = t - h, f = Math.min(l, F), A = new Uint8Array(f);
+            A.set(new Uint8Array(a.memory.buffer, a.dbOffset + h, f)), y.enqueue(A), h += f, h >= t && (i = s > 0 ? "keys" : "done", i === "done" && y.close());
             break;
           }
           case "keys":
-            h.enqueue(s), i = "done", h.close();
+            y.enqueue(r), i = "done", y.close();
             break;
         }
       }
@@ -432,29 +484,29 @@ class b {
    */
   async import(e) {
     this.assertOpen();
-    const t = new V(e), s = await t.readExact(C), A = new DataView(s.buffer, s.byteOffset, s.byteLength);
-    if (A.getUint32(0, !0) !== E)
+    const t = new z(e), r = await t.readExact(M), s = new DataView(r.buffer, r.byteOffset, r.byteLength);
+    if (s.getUint32(0, !0) !== E)
       throw new Error("Invalid import data: unrecognized format");
-    const n = A.getUint32(4, !0);
-    if (n !== d)
-      throw new Error(`Unsupported import version: expected ${d}, got ${n}`);
-    const o = A.getUint32(8, !0);
-    if (o !== this.dimensions)
-      throw new Error(`Import dimension mismatch: expected ${this.dimensions}, got ${o}`);
-    const i = A.getUint32(12, !0), c = A.getUint32(16, !0), h = A.getUint32(20, !0);
+    const o = s.getUint32(4, !0);
+    if (o !== u)
+      throw new Error(`Unsupported import version: expected ${u}, got ${o}`);
+    const a = s.getUint32(8, !0);
+    if (a !== this._dimensions)
+      throw new Error(`Import dimension mismatch: expected ${this._dimensions}, got ${a}`);
+    const i = s.getUint32(12, !0), h = s.getUint32(16, !0), y = s.getUint32(20, !0);
     if (this.keyToSlot.clear(), this.slotToKey.length = 0, this.memoryManager.reset(), i > 0) {
       this.memoryManager.ensureCapacity(i);
-      let g = 0;
-      await t.readChunked(c, (f) => {
-        new Uint8Array(this.memoryManager.memory.buffer, this.memoryManager.dbOffset + g, f.byteLength).set(
+      let l = 0;
+      await t.readChunked(h, (f) => {
+        new Uint8Array(this.memoryManager.memory.buffer, this.memoryManager.dbOffset + l, f.byteLength).set(
           f
-        ), g += f.byteLength;
+        ), l += f.byteLength;
       }), this.memoryManager.setVectorCount(i);
     }
-    if (h > 0) {
-      const g = await t.readExact(h), f = w(g);
-      for (let y = 0; y < f.length; y++)
-        this.keyToSlot.set(f[y], y), this.slotToKey[y] = f[y];
+    if (y > 0) {
+      const l = await t.readExact(y), f = g(l);
+      for (let A = 0; A < f.length; A++)
+        this.keyToSlot.set(f[A], A), this.slotToKey[A] = f[A];
     }
     t.release();
   }
@@ -465,17 +517,17 @@ class b {
     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 s = new Float32Array(this.memoryManager.memory.buffer, t, e.length);
-      e.set(s);
+      const r = new Float32Array(this.memoryManager.memory.buffer, t, e.length);
+      e.set(r);
     } else
-      S(e);
+      v(e);
   }
   assertOpen() {
     if (this.closed)
       throw new Error("VectorDB instance has been closed");
   }
 }
-class V {
+class z {
   reader;
   buffer = new Uint8Array(0);
   constructor(e) {
@@ -485,36 +537,36 @@ class V {
   async readExact(e) {
     if (e === 0) return new Uint8Array(0);
     if (this.buffer.byteLength >= e) {
-      const n = this.buffer.subarray(0, e);
-      return this.buffer = this.buffer.subarray(e), n;
+      const o = this.buffer.subarray(0, e);
+      return this.buffer = this.buffer.subarray(e), o;
     }
     const t = [];
-    let s = this.buffer.byteLength;
-    for (s > 0 && (t.push(this.buffer), this.buffer = new Uint8Array(0)); s < e; ) {
-      const { done: n, value: o } = await this.reader.read();
-      if (n) throw new Error("Invalid import data: unexpected end of stream");
-      t.push(o), s += o.byteLength;
+    let r = this.buffer.byteLength;
+    for (r > 0 && (t.push(this.buffer), this.buffer = new Uint8Array(0)); r < e; ) {
+      const { done: o, value: a } = await this.reader.read();
+      if (o) throw new Error("Invalid import data: unexpected end of stream");
+      t.push(a), r += a.byteLength;
     }
-    const A = new Uint8Array(s);
-    let r = 0;
-    for (const n of t)
-      A.set(n, r), r += n.byteLength;
-    return s > e ? (this.buffer = A.subarray(e), A.subarray(0, e)) : A;
+    const s = new Uint8Array(r);
+    let n = 0;
+    for (const o of t)
+      s.set(o, n), n += o.byteLength;
+    return r > e ? (this.buffer = s.subarray(e), s.subarray(0, e)) : s;
   }
   /**
    * 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 s = e;
+    let r = e;
     if (this.buffer.byteLength > 0) {
-      const A = Math.min(this.buffer.byteLength, s);
-      t(this.buffer.subarray(0, A)), s -= A, this.buffer = this.buffer.subarray(A);
+      const s = Math.min(this.buffer.byteLength, r);
+      t(this.buffer.subarray(0, s)), r -= s, this.buffer = this.buffer.subarray(s);
     }
-    for (; s > 0; ) {
-      const { done: A, value: r } = await this.reader.read();
-      if (A) throw new Error("Invalid import data: unexpected end of stream");
-      r.byteLength <= s ? (t(r), s -= r.byteLength) : (t(r.subarray(0, s)), this.buffer = r.slice(s), s = 0);
+    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);
     }
   }
   /** Release the stream reader lock. */
@@ -523,9 +575,9 @@ class V {
   }
 }
 export {
-  b as DB,
-  F as InMemoryStorageProvider,
-  D as OPFSStorageProvider,
+  I as DB,
+  S as InMemoryStorageProvider,
+  K as OPFSStorageProvider,
   k as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map