eigen-db 4.3.0 → 4.4.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v4.4.0
+
+Added: `entries()`, `keys()`, `values()`, `delete()`, `has()` methods, and `dimensions` property
+
 # v4.3.0
 
 Added: option to choose between in memory or OPFS storage backends

package/README.md

@@ -56,7 +56,34 @@ Notes:
 - Each vector must be a `number[]` (or `Float32Array`) with exactly `dimensions` elements.
 - Duplicate keys use last-write-wins semantics.
 
-### 3) Query nearest vectors
+### 3) Look up, check, and remove vectors
+
+```ts
+db.get("doc:1"); // number[] | undefined
+db.has("doc:1"); // true
+db.delete("doc:1"); // true (removed), false (not found)
+db.dimensions; // configured vector dimensions
+db.size; // number of entries
+```
+
+### 4) Iterate over the database
+
+```ts
+// Iterate over all keys
+for (const key of db.keys()) {
+  console.log(key);
+}
+
+// Iterate over all [key, value] pairs
+for (const [key, vector] of db.entries()) {
+  console.log(key, vector);
+}
+
+// Spread into an array (uses Symbol.iterator, same as entries())
+const all = [...db];
+```
+
+### 5) Query nearest vectors
 
 ```ts
 const queryVector = embeddingQuery;
@@ -94,7 +121,7 @@ const results = db.query(queryVector, { minSimilarity: 0.7 });
 const results = db.query(queryVector, { minSimilarity: 0.7, iterable: true });
 ```
 
-### 4) Persist and lifecycle
+### 6) Persist and lifecycle
 
 ```ts
 await db.flush(); // persist current state
@@ -107,7 +134,7 @@ To delete all vectors and storage:
 await db.clear();
 ```
 
-### 5) Export and import
+### 7) Export and import
 
 Export the entire database as a streaming binary file:
 
@@ -183,6 +210,7 @@ Opens (or creates) a database instance and loads persisted data.
 #### Properties
 
 - `size: number` — current number of key-vector pairs
+- `dimensions: number` — number of dimensions per vector
 
 #### Methods
 
@@ -191,10 +219,20 @@ Opens (or creates) a database instance and loads persisted data.
   - Throws on dimension mismatch.
 - `get(key: string): number[] | undefined`
   - Returns a copy of the stored vector.
+- `has(key: string): boolean`
+  - Returns `true` if the key exists, `false` otherwise. O(1) lookup.
+- `delete(key: string): boolean`
+  - Removes the entry for the given key. Returns `true` if the key existed, `false` otherwise.
 - `setMany(entries: [string, VectorInput][]): void`
   - Batch insert/update.
 - `getMany(keys: string[]): (number[] | undefined)[]`
   - Batch lookup.
+- `keys(): IterableIterator<string>`
+  - Returns an iterable of all keys.
+- `entries(): IterableIterator<[string, number[]]>`
+  - Returns an iterable of `[key, value]` pairs. Values are plain number array copies.
+- `[Symbol.iterator](): IterableIterator<[string, number[]]>`
+  - Same as `entries()`. Enables `[...db]` and `for...of` iteration.
 - `query(value: VectorInput, options?: QueryOptions): ResultItem[]`
   - Returns results sorted by descending similarity as a plain array.
   - Throws on dimension mismatch.

package/dist/compute.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure JavaScript compute functions for vector operations.
+ * These serve as the reference implementation and fallback when WASM SIMD is unavailable.
+ */
+/**
+ * Normalizes a vector in-place to unit length.
+ * After normalization, cosine similarity reduces to a simple dot product.
+ */
+export declare function normalize(vec: Float32Array): void;
+/**
+ * Computes dot products of query against all vectors in the database.
+ * Writes scores to the output array.
+ *
+ * @param query - Normalized query vector (length = dimensions)
+ * @param db - Contiguous flat array of normalized vectors (length = dbSize * dimensions)
+ * @param scores - Output array for dot product scores (length = dbSize)
+ * @param dbSize - Number of vectors in the database
+ * @param dimensions - Dimensionality of each vector
+ */
+export declare function searchAll(query: Float32Array, db: Float32Array, scores: Float32Array, dbSize: number, dimensions: number): void;

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 _ {
+class K {
   dirHandle = null;
   dirName;
   constructor(e) {
@@ -25,8 +25,8 @@ 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();
-    await n.seek(i.size), await n.write(t), await n.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 n = await (await (await this.getDir()).getFileHandle(e, { create: !0 })).createWritable({ keepExistingData: !1 });
@@ -36,15 +36,15 @@ class _ {
     await (await navigator.storage.getDirectory()).removeEntry(this.dirName, { recursive: !0 }), this.dirHandle = null;
   }
 }
-class v {
+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 r = t.reduce((i, a) => i + a.byteLength, 0), s = new Uint8Array(r);
+    const r = t.reduce((o, a) => o + a.byteLength, 0), s = new Uint8Array(r);
     let n = 0;
-    for (const i of t)
-      s.set(i, n), n += i.byteLength;
+    for (const o of t)
+      s.set(o, n), n += o.byteLength;
     return s;
   }
   async append(e, t) {
@@ -57,7 +57,7 @@ class v {
     this.files.clear();
   }
 }
-function S(c) {
+function v(c) {
   let e = 0;
   for (let s = 0; s < c.length; s++)
     e += c[s] * c[s];
@@ -69,19 +69,19 @@ function S(c) {
 }
 function O(c, e, t, r, s) {
   for (let n = 0; n < r; n++) {
-    let i = 0;
+    let o = 0;
     const a = n * s;
-    for (let o = 0; o < s; o++)
-      i += c[o] * e[a + o];
-    t[n] = i;
+    for (let i = 0; i < s; i++)
+      o += c[i] * e[a + i];
+    t[n] = o;
   }
 }
 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);
-  let i = 0;
+  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(i, a.byteLength, !0), i += 4, n.set(a, i), i += a.byteLength;
+    s.setUint32(o, a.byteLength, !0), o += 4, n.set(a, o), o += a.byteLength;
   return n;
 }
 function g(c) {
@@ -96,7 +96,7 @@ function g(c) {
   return e;
 }
 const m = 65536, w = 65536;
-class Q {
+class T {
   memory;
   dimensions;
   queryOffset;
@@ -106,8 +106,8 @@ class Q {
     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));
-    this.memory = new WebAssembly.Memory({ initial: i }), this._vectorCount = t;
+    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() {
@@ -201,59 +201,59 @@ class Q {
     this._vectorCount = e;
   }
 }
-function D(c, e, t, r) {
+function Q(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 });
+  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 L(c, e, t, r) {
+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, o) => c[o] - c[a]);
-  const i = Math.min(t, s);
+  n.sort((a, i) => c[i] - c[a]);
+  const o = Math.min(t, s);
   return {
     [Symbol.iterator]() {
       let a = 0;
       return {
         next() {
-          if (a >= i) return { done: !0, value: void 0 };
-          const o = n[a++], h = c[o];
+          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(o), similarity: h }
+            value: { key: e(i), similarity: h }
           };
         }
       };
     }
   };
 }
-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);
+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 F(c, e) {
+async function L(c, e) {
   const t = { env: { memory: e } };
   return (await WebAssembly.instantiate(c, t)).instance.exports;
 }
-const b = "vectors.bin", E = "keys.bin", C = 1111770949, u = 1, I = 24, z = 65536;
-class M {
+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 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, 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.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 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 y = e.wasmBinary !== void 0 ? e.wasmBinary : T();
-    if (y !== null)
+    const f = e.wasmBinary !== void 0 ? e.wasmBinary : D();
+    if (f !== null)
       try {
-        l = await F(y, f.memory);
+        l = await L(f, y.memory);
       } catch {
       }
-    return new M(f, t, e.dimensions, r, l, o, 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, r) {
-    if (this.assertOpen(), t.length !== this.dimensions)
-      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${t.length}`);
+    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 i = this.keyToSlot.get(e);
-    if (i !== void 0)
-      this.memoryManager.writeVector(i, 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 o = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, o), this.slotToKey[o] = e;
+      const i = this.memoryManager.vectorCount;
+      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, i), this.slotToKey[i] = e;
     }
   }
   /**
@@ -332,50 +384,50 @@ class M {
     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 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 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,
         h,
-        o,
-        this.dimensions
+        i,
+        this._dimensions
       );
     else {
       const A = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.queryOffset,
-        this.dimensions
-      ), B = new Float32Array(
+        this._dimensions
+      ), p = 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);
+        i * this._dimensions
+      ), B = new Float32Array(this.memoryManager.memory.buffer, h, i);
+      O(A, p, B, i, 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()), 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 s = new Uint8Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        e * this.dimensions * 4
+        e * this._dimensions * 4
       );
       t.set(s);
     }
     const r = d(this.slotToKey);
-    await Promise.all([this.storage.write(b, t), this.storage.write(E, r)]);
+    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 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, 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 o = "header", h = 0;
+    let i = "header", h = 0;
     return new ReadableStream({
-      pull(f) {
-        switch (o) {
+      pull(y) {
+        switch (i) {
           case "header":
-            f.enqueue(new Uint8Array(n)), o = t > 0 ? "vectors" : s > 0 ? "keys" : "done", o === "done" && f.close();
+            y.enqueue(new Uint8Array(n)), i = t > 0 ? "vectors" : s > 0 ? "keys" : "done", i === "done" && y.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 - 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":
-            f.enqueue(r), o = "done", f.close();
+            y.enqueue(r), i = "done", y.close();
             break;
         }
       }
@@ -432,29 +484,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 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 i = s.getUint32(4, !0);
-    if (i !== u)
-      throw new Error(`Unsupported import version: expected ${u}, got ${i}`);
+    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 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);
+    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 l = 0;
-      await t.readChunked(h, (y) => {
-        new Uint8Array(this.memoryManager.memory.buffer, this.memoryManager.dbOffset + l, y.byteLength).set(
-          y
-        ), l += y.byteLength;
-      }), this.memoryManager.setVectorCount(o);
+      await t.readChunked(h, (f) => {
+        new Uint8Array(this.memoryManager.memory.buffer, this.memoryManager.dbOffset + l, f.byteLength).set(
+          f
+        ), l += f.byteLength;
+      }), this.memoryManager.setVectorCount(i);
     }
-    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 (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();
   }
@@ -468,14 +520,14 @@ class M {
       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 q {
+class z {
   reader;
   buffer = new Uint8Array(0);
   constructor(e) {
@@ -485,20 +537,20 @@ class q {
   async readExact(e) {
     if (e === 0) return new Uint8Array(0);
     if (this.buffer.byteLength >= e) {
-      const i = this.buffer.subarray(0, e);
-      return this.buffer = this.buffer.subarray(e), i;
+      const o = this.buffer.subarray(0, e);
+      return this.buffer = this.buffer.subarray(e), o;
     }
     const t = [];
     let r = this.buffer.byteLength;
     for (r > 0 && (t.push(this.buffer), this.buffer = new Uint8Array(0)); r < e; ) {
-      const { done: i, value: a } = await this.reader.read();
-      if (i) throw new Error("Invalid import data: unexpected end of stream");
+      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 s = new Uint8Array(r);
     let n = 0;
-    for (const i of t)
-      s.set(i, n), n += i.byteLength;
+    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;
   }
   /**
@@ -523,9 +575,9 @@ class q {
   }
 }
 export {
-  M as DB,
-  v as InMemoryStorageProvider,
-  _ as OPFSStorageProvider,
+  I as DB,
+  S as InMemoryStorageProvider,
+  K as OPFSStorageProvider,
   k as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map