eigen-db 3.0.0 → 4.0.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v4.0.1
+
+Fixed: the source code was stale
+
+# v4.0.0
+
+Changed: `query()` returns simple iterable
+
 # v3.0.0
 
 Changed: Input vectors should be of type `number[]`, not `Float32Array`.

package/README.md

@@ -50,15 +50,27 @@ Notes:
 ```ts
 const queryVector = embeddingQuery;
 
+// Returns a plain array of { key, score } sorted by similarity
 const results = db.query(queryVector, { topK: 10 });
 
-for (let i = 0; i < results.length; i++) {
-  const { key, score } = results.get(i);
-  console.log(i, key, score);
+for (const { key, score } of results) {
+  console.log(key, score);
+}
+```
+
+For lazy iteration (useful for pagination or early stopping):
+
+```ts
+const results = db.query(queryVector, { topK: 100, iterable: true });
+
+// Iterate and break early — keys are resolved on demand
+for (const { key, score } of results) {
+  if (score < 0.5) break;
+  console.log(key, score);
 }
 
-// Or paginate for UI rendering:
-const page0 = results.getPage(0, 10);
+// Or spread into an array when you need all results
+const all = [...results];
 ```
 
 ### 4) Persist and lifecycle
@@ -80,10 +92,9 @@ await db.clear();
 
 ```ts
 export { DB };
-export { ResultSet };
 export type { ResultItem };
 export { VectorCapacityExceededError };
-export type { OpenOptions, OpenOptionsInternal, SetOptions, QueryOptions, VectorInput };
+export type { OpenOptions, OpenOptionsInternal, SetOptions, QueryOptions, IterableQueryOptions, VectorInput };
 export { InMemoryStorageProvider, OPFSStorageProvider };
 export type { StorageProvider };
 ```
@@ -114,8 +125,12 @@ Opens (or creates) a database instance and loads persisted data.
   - Batch insert/update.
 - `getMany(keys: string[]): (number[] | undefined)[]`
   - Batch lookup.
-- `query(value: VectorInput, options?: QueryOptions): ResultSet`
-  - Returns similarity-ranked results.
+- `query(value: VectorInput, options?: QueryOptions): ResultItem[]`
+  - Returns similarity-ranked results as a plain array.
+  - Throws on dimension mismatch.
+- `query(value: VectorInput, options: IterableQueryOptions): Iterable<ResultItem>`
+  - With `{ iterable: true }`, returns a lazy iterable. Keys are resolved
+    only as each item is consumed, enabling early stopping and pagination.
   - Throws on dimension mismatch.
 - `flush(): Promise<void>`
   - Persists in-memory state to storage.
@@ -125,27 +140,6 @@ Opens (or creates) a database instance and loads persisted data.
 - `clear(): Promise<void>`
   - Clears in-memory state and destroys storage for this DB.
 
-### `ResultSet`
-
-Represents a lazily resolved, score-sorted search result collection.
-
-#### Properties
-
-- `length: number` — number of results available (bounded by `topK`)
-
-#### Methods
-
-- `get(rank: number): ResultItem`
-  - Returns the item at rank (`0` is best match).
-  - Throws `RangeError` when out of bounds.
-- `getPage(page: number, pageSize: number): ResultItem[]`
-  - Convenience pagination helper.
-
-#### Static
-
-- `fromScores(scores, resolveKey, topK): ResultSet`
-  - Constructs a sorted lazy result set from raw scores.
-
 ### `ResultItem`
 
 ```ts
@@ -201,6 +195,14 @@ interface QueryOptions {
 }
 ```
 
+#### `IterableQueryOptions`
+
+```ts
+interface IterableQueryOptions extends QueryOptions {
+  iterable: true; // returns Iterable<ResultItem> instead of ResultItem[]
+}
+```
+
 ### Storage
 
 #### `StorageProvider`
@@ -239,5 +241,5 @@ Thrown when memory growth would exceed WASM 32-bit memory limits for the configu
 ## Practical notes
 
 - Similarity is dot product; with normalization enabled (default), this behaves like cosine similarity.
-- Querying an empty database returns a `ResultSet` with `length === 0`.
+- Querying an empty database returns an empty array (`[]`).
 - `flush()` writes deduplicated state, and reopen preserves key-to-slot mapping.

package/dist/eigen-db.js

@@ -3,52 +3,7 @@ class b extends Error {
     super(`Capacity exceeded. Max vectors for this dimension size is ~${e}.`), this.name = "VectorCapacityExceededError";
   }
 }
-class d {
-  /** Total number of results */
-  length;
-  /**
-   * Sorted indices into the original database (by descending score).
-   * sortedIndices[0] is the index of the best match.
-   */
-  sortedIndices;
-  /** Raw scores array (not sorted, indexed by original DB position) */
-  scores;
-  /** Function to lazily resolve key from the slot index */
-  resolveKey;
-  constructor(e, t, r, s) {
-    this.scores = e, this.sortedIndices = t, this.resolveKey = r, this.length = Math.min(s, t.length);
-  }
-  /**
-   * Sort scores and return a ResultSet with lazy key resolution.
-   *
-   * @param scores - Float32Array of scores (one per DB vector)
-   * @param resolveKey - Function to resolve key by original index
-   * @param topK - Maximum number of results to include
-   */
-  static fromScores(e, t, r) {
-    const s = e.length, o = new Uint32Array(s);
-    for (let n = 0; n < s; n++) o[n] = n;
-    return o.sort((n, a) => e[a] - e[n]), new d(e, o, t, r);
-  }
-  /** Fetch a single result by its rank (0 is best match) */
-  get(e) {
-    if (e < 0 || e >= this.length)
-      throw new RangeError(`Rank ${e} out of bounds [0, ${this.length})`);
-    const t = this.sortedIndices[e];
-    return {
-      key: this.resolveKey(t),
-      score: this.scores[t]
-    };
-  }
-  /** Helper for UI pagination. Instantiates strings only for the requested page. */
-  getPage(e, t) {
-    const r = e * t, s = Math.min(r + t, this.length), o = [];
-    for (let n = r; n < s; n++)
-      o.push(this.get(n));
-    return o;
-  }
-}
-class B {
+class E {
   dirHandle = null;
   dirName;
   constructor(e) {
@@ -63,19 +18,19 @@ class B {
   }
   async readAll(e) {
     try {
-      const o = await (await (await (await this.getDir()).getFileHandle(e)).getFile()).arrayBuffer();
-      return new Uint8Array(o);
+      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 s = await (await this.getDir()).getFileHandle(e, { create: !0 }), o = await s.createWritable({ keepExistingData: !0 }), n = await s.getFile();
-    await o.seek(n.size), await o.write(t), await o.close();
+    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) {
-    const o = await (await (await this.getDir()).getFileHandle(e, { create: !0 })).createWritable({ keepExistingData: !1 });
-    await o.write(t), await o.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;
@@ -86,11 +41,11 @@ class D {
   async readAll(e) {
     const t = this.files.get(e);
     if (!t || t.length === 0) return new Uint8Array(0);
-    const r = t.reduce((n, a) => n + a.byteLength, 0), s = new Uint8Array(r);
-    let o = 0;
-    for (const n of t)
-      s.set(n, o), o += n.byteLength;
-    return s;
+    const s = t.reduce((i, o) => i + o.byteLength, 0), r = new Uint8Array(s);
+    let n = 0;
+    for (const i of t)
+      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));
@@ -102,46 +57,46 @@ class D {
     this.files.clear();
   }
 }
-function M(i) {
+function B(a) {
   let e = 0;
-  for (let s = 0; s < i.length; s++)
-    e += i[s] * i[s];
+  for (let r = 0; r < a.length; r++)
+    e += a[r] * a[r];
   const t = Math.sqrt(e);
   if (t === 0) return;
-  const r = 1 / t;
-  for (let s = 0; s < i.length; s++)
-    i[s] *= r;
+  const s = 1 / t;
+  for (let r = 0; r < a.length; r++)
+    a[r] *= s;
 }
-function I(i, e, t, r, s) {
-  for (let o = 0; o < r; o++) {
-    let n = 0;
-    const a = o * s;
-    for (let c = 0; c < s; c++)
-      n += i[c] * e[a + c];
-    t[o] = n;
+function M(a, e, t, s, r) {
+  for (let n = 0; n < s; n++) {
+    let i = 0;
+    const o = n * r;
+    for (let A = 0; A < r; A++)
+      i += a[A] * e[o + A];
+    t[n] = i;
   }
 }
-const Q = new TextEncoder(), S = new TextDecoder();
-function p(i) {
-  const e = i.map((a) => Q.encode(a)), t = e.reduce((a, c) => a + 4 + c.byteLength, 0), r = new ArrayBuffer(t), s = new DataView(r), o = new Uint8Array(r);
-  let n = 0;
-  for (const a of e)
-    s.setUint32(n, a.byteLength, !0), n += 4, o.set(a, n), n += a.byteLength;
-  return o;
+const I = new TextEncoder(), Q = new TextDecoder();
+function S(a) {
+  const e = a.map((o) => I.encode(o)), t = e.reduce((o, A) => o + 4 + A.byteLength, 0), s = new ArrayBuffer(t), r = new DataView(s), n = new Uint8Array(s);
+  let i = 0;
+  for (const o of e)
+    r.setUint32(i, o.byteLength, !0), i += 4, n.set(o, i), i += o.byteLength;
+  return n;
 }
-function O(i) {
-  const e = [], t = new DataView(i.buffer, i.byteOffset, i.byteLength);
-  let r = 0;
-  for (; r < i.byteLength; ) {
-    const s = t.getUint32(r, !0);
-    r += 4;
-    const o = S.decode(i.subarray(r, r + s));
-    e.push(o), r += s;
+function O(a) {
+  const e = [], t = new DataView(a.buffer, a.byteOffset, a.byteLength);
+  let s = 0;
+  for (; s < a.byteLength; ) {
+    const r = t.getUint32(s, !0);
+    s += 4;
+    const n = Q.decode(a.subarray(s, s + r));
+    e.push(n), s += r;
   }
   return e;
 }
-const l = 65536, w = 65536;
-class x {
+const y = 65536, d = 65536;
+class p {
   memory;
   dimensions;
   queryOffset;
@@ -149,10 +104,10 @@ class x {
   _vectorCount;
   constructor(e, t = 0) {
     this.dimensions = e, this.queryOffset = 0;
-    const r = e * 4;
-    this.dbOffset = Math.ceil(r / l) * l;
-    const s = t * e * 4, o = this.dbOffset + s, n = Math.max(1, Math.ceil(o / l));
-    this.memory = new WebAssembly.Memory({ initial: n }), this._vectorCount = t;
+    const s = e * 4;
+    this.dbOffset = Math.ceil(s / y) * y;
+    const r = t * e * 4, n = this.dbOffset + r, i = Math.max(1, Math.ceil(n / y));
+    this.memory = new WebAssembly.Memory({ initial: i }), this._vectorCount = t;
   }
   /** Current number of vectors stored */
   get vectorCount() {
@@ -171,7 +126,7 @@ class x {
    * Accounts for query buffer, DB space, and scores buffer.
    */
   get maxVectors() {
-    const e = w * l - this.dbOffset, t = this.dimensions * 4 + 4;
+    const e = d * y - this.dbOffset, t = this.dimensions * 4 + 4;
     return Math.floor(e / t);
   }
   /**
@@ -179,12 +134,12 @@ class x {
    * 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 o = Math.ceil((r - s) / l);
-      if (s / l + o > 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) / y);
+      if (r / y + n > d)
         throw new Error("WASM memory limit exceeded");
-      this.memory.grow(o);
+      this.memory.grow(n);
     }
   }
   /**
@@ -199,9 +154,9 @@ class x {
    */
   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;
   }
   /**
@@ -228,8 +183,8 @@ class x {
    * 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.
@@ -239,19 +194,55 @@ class x {
     this._vectorCount = 0;
   }
 }
-const v = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKsgQCtQIFAX8BewN9AXsDf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQogAyAK/QAEACAK/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAEIAoqAgAgCioCAJSSIQQgCUEBaiEJDAALCyAEkSEFIAVDAAAAAFsEQA8LQwAAgD8gBZUhBiAG/RMhB0EAIQICQANAIAIgCE8NASAAIAJBAnRqIQogCiAK/QAEACAH/eYB/QsEACACQQRqIQIMAAsLIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAKIAoqAgAgBpQ4AgAgCUEBaiEJDAALCwv4AQQCfwF7AX0GfyAEQXxxIQogBEECdCEOQQAhBQJAA0AgBSADTw0BIAEgBSAObGohCf0MAAAAAAAAAAAAAAAAAAAAACEHQQAhBgJAA0AgBiAKTw0BIAAgBkECdGohDCAJIAZBAnRqIQ0gByAM/QAEACAN/QAEAP3mAf3kASEHIAZBBGohBgwACwsgB/0fACAH/R8BkiAH/R8CIAf9HwOSkiEIIAohCwJAA0AgCyAETw0BIAAgC0ECdGohDCAJIAtBAnRqIQ0gCCAMKgIAIA0qAgCUkiEIIAtBAWohCwwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
+function x(a, e, t) {
+  const s = a.length;
+  if (s === 0) return [];
+  const r = new Uint32Array(s);
+  for (let o = 0; o < s; o++) r[o] = o;
+  r.sort((o, A) => a[A] - a[o]);
+  const n = Math.min(t, s), i = new Array(n);
+  for (let o = 0; o < n; o++) {
+    const A = r[o];
+    i[o] = { key: e(A), score: a[A] };
+  }
+  return i;
+}
+function v(a, e, t) {
+  const s = a.length;
+  if (s === 0) return [];
+  const r = new Uint32Array(s);
+  for (let i = 0; i < s; i++) r[i] = i;
+  r.sort((i, o) => a[o] - a[i]);
+  const n = Math.min(t, s);
+  return {
+    [Symbol.iterator]() {
+      let i = 0;
+      return {
+        next() {
+          if (i >= n) return { done: !0, value: void 0 };
+          const o = r[i++];
+          return {
+            done: !1,
+            value: { key: e(o), score: a[o] }
+          };
+        }
+      };
+    }
+  };
+}
+const k = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKsgQCtQIFAX8BewN9AXsDf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQogAyAK/QAEACAK/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAEIAoqAgAgCioCAJSSIQQgCUEBaiEJDAALCyAEkSEFIAVDAAAAAFsEQA8LQwAAgD8gBZUhBiAG/RMhB0EAIQICQANAIAIgCE8NASAAIAJBAnRqIQogCiAK/QAEACAH/eYB/QsEACACQQRqIQIMAAsLIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAKIAoqAgAgBpQ4AgAgCUEBaiEJDAALCwv4AQQCfwF7AX0GfyAEQXxxIQogBEECdCEOQQAhBQJAA0AgBSADTw0BIAEgBSAObGohCf0MAAAAAAAAAAAAAAAAAAAAACEHQQAhBgJAA0AgBiAKTw0BIAAgBkECdGohDCAJIAZBAnRqIQ0gByAM/QAEACAN/QAEAP3mAf3kASEHIAZBBGohBgwACwsgB/0fACAH/R8BkiAH/R8CIAf9HwOSkiEIIAohCwJAA0AgCyAETw0BIAAgC0ECdGohDCAJIAtBAnRqIQ0gCCAMKgIAIA0qAgCUkiEIIAtBAWohCwwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
 function F() {
-  const i = atob(v), e = new Uint8Array(i.length);
-  for (let t = 0; t < i.length; t++)
-    e[t] = i.charCodeAt(t);
+  const a = atob(k), e = new Uint8Array(a.length);
+  for (let t = 0; t < a.length; t++)
+    e[t] = a.charCodeAt(t);
   return e;
 }
-async function V(i, e) {
+async function V(a, e) {
   const t = { env: { memory: e } };
-  return (await WebAssembly.instantiate(i, t)).instance.exports;
+  return (await WebAssembly.instantiate(a, t)).instance.exports;
 }
-const u = "vectors.bin", C = "keys.bin";
-class E {
+const u = "vectors.bin", w = "keys.bin";
+class C {
   memoryManager;
   storage;
   dimensions;
@@ -263,23 +254,23 @@ class E {
   slotToKey;
   /** Whether this instance has been closed */
   closed = !1;
-  constructor(e, t, r, s, o, n, a) {
-    this.memoryManager = e, this.storage = t, this.dimensions = r, this.shouldNormalize = s, this.wasmExports = o, this.keyToSlot = n, this.slotToKey = a;
+  constructor(e, t, s, r, n, i, o) {
+    this.memoryManager = e, this.storage = t, this.dimensions = s, this.shouldNormalize = r, this.wasmExports = n, this.keyToSlot = i, this.slotToKey = o;
   }
   static async open(e) {
-    const t = e.name ?? "default", r = e.storage ?? new B(t), s = e.normalize !== !1, [o, n] = await Promise.all([r.readAll(u), r.readAll(C)]), a = n.byteLength > 0 ? O(n) : [], c = o.byteLength / (e.dimensions * 4), m = /* @__PURE__ */ new Map(), y = [];
-    for (let h = 0; h < a.length; h++)
-      m.set(a[h], h), y[h] = a[h];
-    const A = new x(e.dimensions, c);
-    o.byteLength > 0 && A.loadVectorBytes(o, c);
-    let f = null;
+    const t = e.name ?? "default", s = e.storage ?? new E(t), r = e.normalize !== !1, [n, i] = await Promise.all([s.readAll(u), s.readAll(w)]), o = i.byteLength > 0 ? O(i) : [], A = n.byteLength / (e.dimensions * 4), m = /* @__PURE__ */ new Map(), f = [];
+    for (let c = 0; c < o.length; c++)
+      m.set(o[c], c), f[c] = o[c];
+    const h = new p(e.dimensions, A);
+    n.byteLength > 0 && h.loadVectorBytes(n, A);
+    let l = null;
     const g = e.wasmBinary !== void 0 ? e.wasmBinary : F();
     if (g !== null)
       try {
-        f = await V(g, A.memory);
+        l = await V(g, h.memory);
       } catch {
       }
-    return new E(A, r, e.dimensions, s, f, m, y);
+    return new C(h, s, e.dimensions, r, l, m, f);
   }
   /** Total number of key-value pairs in the database */
   get size() {
@@ -289,20 +280,20 @@ class E {
    * 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) {
+  set(e, t, s) {
     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 n = this.keyToSlot.get(e);
-    if (n !== void 0)
-      this.memoryManager.writeVector(n, s);
+    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, r);
     else {
       if (this.memoryManager.vectorCount + 1 > this.memoryManager.maxVectors)
         throw new b(this.memoryManager.maxVectors);
       this.memoryManager.ensureCapacity(1);
-      const c = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, c), this.slotToKey[c] = e;
+      const A = this.memoryManager.vectorCount;
+      this.memoryManager.appendVectors([r]), this.keyToSlot.set(e, A), this.slotToKey[A] = e;
     }
   }
   /**
@@ -319,8 +310,8 @@ class E {
    * 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.
@@ -328,42 +319,38 @@ class E {
   getMany(e) {
     return e.map((t) => this.get(t));
   }
-  /**
-   * Search for the most similar vectors to the given query vector.
-   * Returns a ResultSet sorted by descending similarity score.
-   */
   query(e, t) {
     this.assertOpen();
-    const r = t?.topK ?? this.size;
+    const s = t?.topK ?? this.size, r = t && "iterable" in t && t.iterable;
     if (this.size === 0)
-      return d.fromScores(new Float32Array(0), () => "", 0);
+      return [];
     if (e.length !== this.dimensions)
       throw new Error(`Query vector dimension mismatch: expected ${this.dimensions}, got ${e.length}`);
-    const s = new Float32Array(e);
-    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(s), this.memoryManager.writeQuery(s), this.memoryManager.ensureCapacity(0);
-    const n = this.memoryManager.vectorCount, a = this.memoryManager.scoresOffset;
+    const n = new Float32Array(e);
+    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(n), this.memoryManager.writeQuery(n), this.memoryManager.ensureCapacity(0);
+    const o = this.memoryManager.vectorCount, A = this.memoryManager.scoresOffset;
     if (this.wasmExports)
       this.wasmExports.search_all(
         this.memoryManager.queryOffset,
         this.memoryManager.dbOffset,
-        a,
-        n,
+        A,
+        o,
         this.dimensions
       );
     else {
-      const A = new Float32Array(
+      const l = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.queryOffset,
         this.dimensions
-      ), f = new Float32Array(
+      ), g = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        n * this.dimensions
-      ), g = new Float32Array(this.memoryManager.memory.buffer, a, n);
-      I(A, f, g, n, this.dimensions);
+        o * this.dimensions
+      ), c = new Float32Array(this.memoryManager.memory.buffer, A, o);
+      M(l, g, c, o, this.dimensions);
     }
-    const c = new Float32Array(this.memoryManager.readScores()), m = this.slotToKey, y = (A) => m[A];
-    return d.fromScores(c, y, r);
+    const m = new Float32Array(this.memoryManager.readScores()), f = this.slotToKey, h = (l) => f[l];
+    return r ? v(m, h, s) : x(m, h, s);
   }
   /**
    * Persist the current in-memory state to storage.
@@ -372,15 +359,15 @@ class E {
     this.assertOpen();
     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
       );
-      t.set(s);
+      t.set(r);
     }
-    const r = p(this.slotToKey);
-    await Promise.all([this.storage.write(u, t), this.storage.write(C, r)]);
+    const s = S(this.slotToKey);
+    await Promise.all([this.storage.write(u, t), this.storage.write(w, s)]);
   }
   /**
    * Flush data to storage and release the instance.
@@ -402,10 +389,10 @@ class E {
     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
-      M(e);
+      B(e);
   }
   assertOpen() {
     if (this.closed)
@@ -413,10 +400,9 @@ class E {
   }
 }
 export {
-  E as DB,
+  C as DB,
   D as InMemoryStorageProvider,
-  B as OPFSStorageProvider,
-  d as ResultSet,
+  E as OPFSStorageProvider,
   b as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map