eigen-db 4.1.0 → 4.3.0

package/dist/eigen-db.js

@@ -1,113 +1,113 @@
-class Q extends Error {
-  constructor(A) {
-    super(`Capacity exceeded. Max vectors for this dimension size is ~${A}.`), this.name = "VectorCapacityExceededError";
+class k extends Error {
+  constructor(e) {
+    super(`Capacity exceeded. Max vectors for this dimension size is ~${e}.`), this.name = "VectorCapacityExceededError";
   }
 }
-class C {
+class _ {
   dirHandle = null;
   dirName;
-  constructor(A) {
-    this.dirName = A;
+  constructor(e) {
+    this.dirName = e;
   }
   async getDir() {
     if (!this.dirHandle) {
-      const A = await navigator.storage.getDirectory();
-      this.dirHandle = await A.getDirectoryHandle(this.dirName, { create: !0 });
+      const e = await navigator.storage.getDirectory();
+      this.dirHandle = await e.getDirectoryHandle(this.dirName, { create: !0 });
     }
     return this.dirHandle;
   }
-  async readAll(A) {
+  async readAll(e) {
     try {
-      const r = await (await (await (await this.getDir()).getFileHandle(A)).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(A, e) {
-    const t = await (await this.getDir()).getFileHandle(A, { create: !0 }), r = await t.createWritable({ keepExistingData: !0 }), o = await t.getFile();
-    await r.seek(o.size), await r.write(e), await r.close();
+  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();
   }
-  async write(A, e) {
-    const r = await (await (await this.getDir()).getFileHandle(A, { create: !0 })).createWritable({ keepExistingData: !1 });
-    await r.write(e), await r.close();
+  async write(e, t) {
+    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 O {
+class v {
   files = /* @__PURE__ */ new Map();
-  async readAll(A) {
-    const e = this.files.get(A);
-    if (!e || e.length === 0) return new Uint8Array(0);
-    const s = e.reduce((o, a) => o + a.byteLength, 0), t = new Uint8Array(s);
-    let r = 0;
-    for (const o of e)
-      t.set(o, r), r += o.byteLength;
-    return t;
+  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);
+    let n = 0;
+    for (const i of t)
+      s.set(i, n), n += i.byteLength;
+    return s;
   }
-  async append(A, e) {
-    this.files.has(A) || this.files.set(A, []), this.files.get(A).push(new Uint8Array(e));
+  async append(e, t) {
+    this.files.has(e) || this.files.set(e, []), this.files.get(e).push(new Uint8Array(t));
   }
-  async write(A, e) {
-    this.files.set(A, [new Uint8Array(e)]);
+  async write(e, t) {
+    this.files.set(e, [new Uint8Array(t)]);
   }
   async destroy() {
     this.files.clear();
   }
 }
-function E(n) {
-  let A = 0;
-  for (let t = 0; t < n.length; t++)
-    A += n[t] * n[t];
-  const e = Math.sqrt(A);
-  if (e === 0) return;
-  const s = 1 / e;
-  for (let t = 0; t < n.length; t++)
-    n[t] *= s;
+function S(c) {
+  let e = 0;
+  for (let s = 0; s < c.length; s++)
+    e += c[s] * c[s];
+  const t = Math.sqrt(e);
+  if (t === 0) return;
+  const r = 1 / t;
+  for (let s = 0; s < c.length; s++)
+    c[s] *= r;
 }
-function b(n, A, e, s, t) {
-  for (let r = 0; r < s; r++) {
-    let o = 0;
-    const a = r * t;
-    for (let i = 0; i < t; i++)
-      o += n[i] * A[a + i];
-    e[r] = o;
+function O(c, e, t, r, s) {
+  for (let n = 0; n < r; n++) {
+    let i = 0;
+    const a = n * s;
+    for (let o = 0; o < s; o++)
+      i += c[o] * e[a + o];
+    t[n] = i;
   }
 }
-const M = new TextEncoder(), D = new TextDecoder();
-function S(n) {
-  const A = n.map((a) => M.encode(a)), e = A.reduce((a, i) => a + 4 + i.byteLength, 0), s = new ArrayBuffer(e), t = new DataView(s), r = new Uint8Array(s);
-  let o = 0;
-  for (const a of A)
-    t.setUint32(o, a.byteLength, !0), o += 4, r.set(a, o), o += a.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, o) => a + 4 + o.byteLength, 0), r = new ArrayBuffer(t), s = new DataView(r), n = new Uint8Array(r);
+  let i = 0;
+  for (const a of e)
+    s.setUint32(i, a.byteLength, !0), i += 4, n.set(a, i), i += a.byteLength;
+  return n;
 }
-function k(n) {
-  const A = [], e = new DataView(n.buffer, n.byteOffset, n.byteLength);
-  let s = 0;
-  for (; s < n.byteLength; ) {
-    const t = e.getUint32(s, !0);
-    s += 4;
-    const r = D.decode(n.subarray(s, s + t));
-    A.push(r), s += t;
-  }
-  return 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 f = 65536, d = 65536;
-class v {
+const m = 65536, w = 65536;
+class Q {
   memory;
   dimensions;
   queryOffset;
   dbOffset;
   _vectorCount;
-  constructor(A, e = 0) {
-    this.dimensions = A, this.queryOffset = 0;
-    const s = A * 4;
-    this.dbOffset = Math.ceil(s / f) * f;
-    const t = e * A * 4, r = this.dbOffset + t, o = Math.max(1, Math.ceil(r / f));
-    this.memory = new WebAssembly.Memory({ initial: o }), this._vectorCount = e;
+  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));
+    this.memory = new WebAssembly.Memory({ initial: i }), this._vectorCount = t;
   }
   /** Current number of vectors stored */
   get vectorCount() {
@@ -126,45 +126,45 @@ class v {
    * Accounts for query buffer, DB space, and scores buffer.
    */
   get maxVectors() {
-    const A = d * f - this.dbOffset, e = this.dimensions * 4 + 4;
-    return Math.floor(A / e);
+    const e = w * m - this.dbOffset, t = this.dimensions * 4 + 4;
+    return Math.floor(e / t);
   }
   /**
    * Ensures memory is large enough for the current DB + scores buffer.
    * Calls memory.grow() if needed.
    */
-  ensureCapacity(A) {
-    const e = this._vectorCount + A, s = this.dbOffset + e * this.dimensions * 4 + e * 4, t = this.memory.buffer.byteLength;
-    if (s > t) {
-      const r = Math.ceil((s - t) / f);
-      if (t / f + r > d)
+  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)
         throw new Error("WASM memory limit exceeded");
-      this.memory.grow(r);
+      this.memory.grow(n);
     }
   }
   /**
    * Write a query vector into the query buffer region.
    */
-  writeQuery(A) {
-    new Float32Array(this.memory.buffer, this.queryOffset, this.dimensions).set(A);
+  writeQuery(e) {
+    new Float32Array(this.memory.buffer, this.queryOffset, this.dimensions).set(e);
   }
   /**
    * Append vectors to the database region.
    * Returns the byte offset where the new vectors were written.
    */
-  appendVectors(A) {
-    const e = this.dbOffset + this._vectorCount * this.dimensions * 4;
-    let s = e;
-    for (const t of A)
-      new Float32Array(this.memory.buffer, s, this.dimensions).set(t), s += this.dimensions * 4;
-    return this._vectorCount += A.length, e;
+  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;
+    return this._vectorCount += e.length, t;
   }
   /**
    * Load raw vector bytes directly into the database region.
    * Used for bulk loading from OPFS.
    */
-  loadVectorBytes(A, e) {
-    new Uint8Array(this.memory.buffer, this.dbOffset, A.byteLength).set(A), this._vectorCount = e;
+  loadVectorBytes(e, t) {
+    new Uint8Array(this.memory.buffer, this.dbOffset, e.byteLength).set(e), this._vectorCount = t;
   }
   /**
    * Read the scores buffer as a Float32Array view.
@@ -175,16 +175,16 @@ class v {
   /**
    * Read the DB region for a specific vector index.
    */
-  readVector(A) {
-    const e = this.dbOffset + A * this.dimensions * 4;
-    return new Float32Array(this.memory.buffer, e, this.dimensions);
+  readVector(e) {
+    const t = this.dbOffset + e * this.dimensions * 4;
+    return new Float32Array(this.memory.buffer, t, this.dimensions);
   }
   /**
    * Write a vector to a specific slot in the database region.
    */
-  writeVector(A, e) {
-    const s = this.dbOffset + A * this.dimensions * 4;
-    new Float32Array(this.memory.buffer, s, this.dimensions).set(e);
+  writeVector(e, 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.
@@ -193,57 +193,64 @@ class v {
   reset() {
     this._vectorCount = 0;
   }
+  /**
+   * Set the vector count after bulk-loading data directly into the DB region.
+   * Use when writing raw bytes to the DB region externally (e.g., streaming import).
+   */
+  setVectorCount(e) {
+    this._vectorCount = e;
+  }
 }
-function G(n, A, e, s) {
-  const t = n.length;
-  if (t === 0) return [];
-  const r = new Uint32Array(t);
-  for (let i = 0; i < t; i++) r[i] = i;
-  r.sort((i, c) => n[c] - n[i]);
-  const o = Math.min(e, t), a = [];
-  for (let i = 0; i < o; i++) {
-    const c = r[i], h = 1 - n[c];
-    if (s !== void 0 && h > s) break;
-    a.push({ key: A(c), distance: h });
+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 x(n, A, e, s) {
-  const t = n.length;
-  if (t === 0) return [];
-  const r = new Uint32Array(t);
-  for (let a = 0; a < t; a++) r[a] = a;
-  r.sort((a, i) => n[i] - n[a]);
-  const o = Math.min(e, 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 {
     [Symbol.iterator]() {
       let a = 0;
       return {
         next() {
-          if (a >= o) return { done: !0, value: void 0 };
-          const i = r[a++], c = 1 - n[i];
-          return s !== void 0 && c > s ? { done: !0, value: void 0 } : {
+          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: A(i), distance: c }
+            value: { key: e(o), similarity: h }
           };
         }
       };
     }
   };
 }
-const H = "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";
-function p() {
-  const n = atob(H), A = new Uint8Array(n.length);
-  for (let e = 0; e < n.length; e++)
-    A[e] = n.charCodeAt(e);
-  return A;
+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);
+  return e;
 }
-async function F(n, A) {
-  const e = { env: { memory: A } };
-  return (await WebAssembly.instantiate(n, e)).instance.exports;
+async function F(c, e) {
+  const t = { env: { memory: e } };
+  return (await WebAssembly.instantiate(c, t)).instance.exports;
 }
-const B = "vectors.bin", I = "keys.bin";
-class w {
+const b = "vectors.bin", E = "keys.bin", C = 1111770949, u = 1, I = 24, z = 65536;
+class M {
   memoryManager;
   storage;
   dimensions;
@@ -255,23 +262,23 @@ class w {
   slotToKey;
   /** Whether this instance has been closed */
   closed = !1;
-  constructor(A, e, s, t, r, o, a) {
-    this.memoryManager = A, this.storage = e, this.dimensions = s, this.shouldNormalize = t, this.wasmExports = r, this.keyToSlot = o, this.slotToKey = a;
-  }
-  static async open(A) {
-    const e = A.name ?? "default", s = A.storage ?? new C(e), t = A.normalize !== !1, [r, o] = await Promise.all([s.readAll(B), s.readAll(I)]), a = o.byteLength > 0 ? k(o) : [], i = r.byteLength / (A.dimensions * 4), c = /* @__PURE__ */ new Map(), h = [];
-    for (let g = 0; g < a.length; g++)
-      c.set(a[g], g), h[g] = a[g];
-    const y = new v(A.dimensions, i);
-    r.byteLength > 0 && y.loadVectorBytes(r, i);
-    let m = null;
-    const l = A.wasmBinary !== void 0 ? A.wasmBinary : p();
-    if (l !== null)
+  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;
+  }
+  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);
+    let l = null;
+    const y = e.wasmBinary !== void 0 ? e.wasmBinary : T();
+    if (y !== null)
       try {
-        m = await F(l, y.memory);
+        l = await F(y, f.memory);
       } catch {
       }
-    return new w(y, s, A.dimensions, t, m, c, h);
+    return new M(f, t, e.dimensions, r, l, o, h);
   }
   /** Total number of key-value pairs in the database */
   get size() {
@@ -281,94 +288,94 @@ class w {
    * 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(A, e, s) {
-    if (this.assertOpen(), e.length !== this.dimensions)
-      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${e.length}`);
-    const t = new Float32Array(e);
-    (s?.normalize ?? this.shouldNormalize) && this.normalizeVector(t);
-    const o = this.keyToSlot.get(A);
-    if (o !== void 0)
-      this.memoryManager.writeVector(o, t);
+  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 i = this.keyToSlot.get(e);
+    if (i !== void 0)
+      this.memoryManager.writeVector(i, s);
     else {
       if (this.memoryManager.vectorCount + 1 > this.memoryManager.maxVectors)
-        throw new Q(this.memoryManager.maxVectors);
+        throw new k(this.memoryManager.maxVectors);
       this.memoryManager.ensureCapacity(1);
-      const i = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([t]), this.keyToSlot.set(A, i), this.slotToKey[i] = A;
+      const o = this.memoryManager.vectorCount;
+      this.memoryManager.appendVectors([s]), this.keyToSlot.set(e, o), this.slotToKey[o] = e;
     }
   }
   /**
    * Get the stored vector for a key. Returns undefined if the key does not exist.
    * Returns a copy of the stored vector as a plain number array.
    */
-  get(A) {
+  get(e) {
     this.assertOpen();
-    const e = this.keyToSlot.get(A);
-    if (e !== void 0)
-      return Array.from(this.memoryManager.readVector(e));
+    const t = this.keyToSlot.get(e);
+    if (t !== void 0)
+      return Array.from(this.memoryManager.readVector(t));
   }
   /**
    * Set multiple key-value pairs at once. Last-write-wins applies within the batch.
    */
-  setMany(A) {
-    for (const [e, s] of A)
-      this.set(e, s);
+  setMany(e) {
+    for (const [t, r] of e)
+      this.set(t, r);
   }
   /**
    * Get vectors for multiple keys. Returns undefined for keys that don't exist.
    */
-  getMany(A) {
-    return A.map((e) => this.get(e));
+  getMany(e) {
+    return e.map((t) => this.get(t));
   }
-  query(A, e) {
+  query(e, t) {
     this.assertOpen();
-    const s = e?.topK ?? 1 / 0, t = e?.maxDistance, r = e && "iterable" in e && e.iterable;
+    const r = t?.topK ?? 1 / 0, s = t?.minSimilarity, n = t && "iterable" in t && t.iterable;
     if (this.size === 0)
       return [];
-    if (A.length !== this.dimensions)
-      throw new Error(`Query vector dimension mismatch: expected ${this.dimensions}, got ${A.length}`);
-    const o = new Float32Array(A);
-    (e?.normalize ?? this.shouldNormalize) && this.normalizeVector(o), this.memoryManager.writeQuery(o), 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 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 (this.wasmExports)
       this.wasmExports.search_all(
         this.memoryManager.queryOffset,
         this.memoryManager.dbOffset,
-        c,
-        i,
+        h,
+        o,
         this.dimensions
       );
     else {
-      const l = new Float32Array(
+      const A = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.queryOffset,
         this.dimensions
-      ), g = new Float32Array(
+      ), B = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        i * this.dimensions
-      ), u = new Float32Array(this.memoryManager.memory.buffer, c, i);
-      b(l, g, u, i, this.dimensions);
+        o * this.dimensions
+      ), p = new Float32Array(this.memoryManager.memory.buffer, h, o);
+      O(A, B, p, o, this.dimensions);
     }
-    const h = new Float32Array(this.memoryManager.readScores()), y = this.slotToKey, m = (l) => y[l];
-    return r ? x(h, m, s, t) : G(h, m, s, t);
+    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);
   }
   /**
    * Persist the current in-memory state to storage.
    */
   async flush() {
     this.assertOpen();
-    const A = this.memoryManager.vectorCount, e = new Uint8Array(A * this.dimensions * 4);
-    if (A > 0) {
-      const t = new Uint8Array(
+    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,
-        A * this.dimensions * 4
+        e * this.dimensions * 4
       );
-      e.set(t);
+      t.set(s);
     }
-    const s = S(this.slotToKey);
-    await Promise.all([this.storage.write(B, e), this.storage.write(I, s)]);
+    const r = d(this.slotToKey);
+    await Promise.all([this.storage.write(b, t), this.storage.write(E, r)]);
   }
   /**
    * Flush data to storage and release the instance.
@@ -383,27 +390,142 @@ class w {
   async clear() {
     this.assertOpen(), this.keyToSlot.clear(), this.slotToKey.length = 0, this.memoryManager.reset(), await this.storage.destroy();
   }
+  /**
+   * Export the entire database as a ReadableStream of binary chunks.
+   *
+   * Format: [Header 24 bytes][Vector data][Keys data]
+   * Header: magic(4) + version(4) + dimensions(4) + vectorCount(4) + vectorDataLen(4) + keysDataLen(4)
+   *
+   * Vectors are streamed in 64KB chunks from WASM memory to avoid large
+   * heap allocations.
+   */
+  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 a = this.memoryManager;
+    let o = "header", h = 0;
+    return new ReadableStream({
+      pull(f) {
+        switch (o) {
+          case "header":
+            f.enqueue(new Uint8Array(n)), o = t > 0 ? "vectors" : s > 0 ? "keys" : "done", o === "done" && f.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());
+            break;
+          }
+          case "keys":
+            f.enqueue(r), o = "done", f.close();
+            break;
+        }
+      }
+    });
+  }
+  /**
+   * Import data from a ReadableStream, replacing all existing data.
+   * Performs a dimension check against the configured dimensions.
+   *
+   * Vectors are streamed directly into WASM memory in chunks to avoid
+   * large heap allocations.
+   */
+  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)
+      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);
+      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);
+    }
+    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];
+    }
+    t.release();
+  }
   /**
    * Normalize a vector using WASM (if available) or JS fallback.
    */
-  normalizeVector(A) {
+  normalizeVector(e) {
     if (this.wasmExports) {
-      const e = this.memoryManager.queryOffset;
-      new Float32Array(this.memoryManager.memory.buffer, e, A.length).set(A), this.wasmExports.normalize(e, A.length);
-      const s = new Float32Array(this.memoryManager.memory.buffer, e, A.length);
-      A.set(s);
+      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);
     } else
-      E(A);
+      S(e);
   }
   assertOpen() {
     if (this.closed)
       throw new Error("VectorDB instance has been closed");
   }
 }
+class q {
+  reader;
+  buffer = new Uint8Array(0);
+  constructor(e) {
+    this.reader = e.getReader();
+  }
+  /** Read exactly `n` bytes, accumulating from stream chunks as needed. */
+  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 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");
+      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;
+    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 r = 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);
+    }
+    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. */
+  release() {
+    this.reader.releaseLock();
+  }
+}
 export {
-  w as DB,
-  O as InMemoryStorageProvider,
-  C as OPFSStorageProvider,
-  Q as VectorCapacityExceededError
+  M as DB,
+  v as InMemoryStorageProvider,
+  _ as OPFSStorageProvider,
+  k as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map