@delali/narsil 0.2.2-next.29 → 0.2.3-next.32

package/dist/{chunk-S7RJJMHI.mjs → chunk-WDL632CN.mjs}

@@ -1,5 +1,8 @@
+import { compareCodePoints } from './chunk-BFIH7OV5.mjs';
+
 // src/vector/simd-wasm-binary.ts
 var SIMD_DISTANCE_WASM_BASE64 = "AGFzbQEAAAABFQNgA39/fwF9YAJ/fwF9YAN/f38BfwMHBgABAAACAgUDAQABB2sHBm1lbW9yeQIAC2RvdF9wcm9kdWN0AAAJbWFnbml0dWRlAAEac3F1YXJlZF9ldWNsaWRlYW5fZGlzdGFuY2UAAhJldWNsaWRlYW5fZGlzdGFuY2UAAwZkb3RfdTgABAlzcWRpc3RfdTgABQqvBwauAQQBfwF7AX0BfyACQXxxIQb9DAAAAAAAAAAAAAAAAAAAAAAhBEEAIQMCQANAIAMgBk8NASAEIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eYB/eQBIQQgA0EEaiEDDAALCyAE/R8AIAT9HwGSIAT9HwIgBP0fA5KSIQUCQANAIAMgAk8NASAFIAAgA0ECdGoqAgAgASADQQJ0aioCAJSSIQUgA0EBaiEDDAALCyAFC6kBBAF/AnsBfQF/IAFBfHEhBv0MAAAAAAAAAAAAAAAAAAAAACEDQQAhAgJAA0AgAiAGTw0BIAAgAkECdGr9AAQAIQQgAyAEIAT95gH95AEhAyACQQRqIQIMAAsLIAP9HwAgA/0fAZIgA/0fAiAD/R8DkpIhBQJAA0AgAiABTw0BIAUgACACQQJ0aioCACAAIAJBAnRqKgIAlJIhBSACQQFqIQIMAAsLIAWRC8ABBQF/AnsBfQF/AX0gAkF8cSEH/QwAAAAAAAAAAAAAAAAAAAAAIQRBACEDAkADQCADIAdPDQEgACADQQJ0av0ABAAgASADQQJ0av0ABAD95QEhBSAEIAUgBf3mAf3kASEEIANBBGohAwwACwsgBP0fACAE/R8BkiAE/R8CIAT9HwOSkiEGAkADQCADIAJPDQEgACADQQJ0aioCACABIANBAnRqKgIAkyEIIAYgCCAIlJIhBiADQQFqIQMMAAsLIAYLCwAgACABIAIQApELtAEDAX8DewJ/IAJBcHEhCEEA/REhBEEAIQMCQANAIAMgCE8NASAAIANq/QAEACEFIAEgA2r9AAQAIQYgBCAF/YkBIAb9iQH9ugH9rgEhBCAEIAX9igEgBv2KAf26Af2uASEEIANBEGohAwwACwsgBP0bACAE/RsBaiAE/RsCIAT9GwNqaiEHAkADQCADIAJPDQEgByAAIANqLQAAIAEgA2otAABsaiEHIANBAWohAwwACwsgBwvNAQMBfwV7A38gAkFwcSELQQD9ESEEQQAhAwJAA0AgAyALTw0BIAAgA2r9AAQAIQUgASADav0ABAAhBiAF/YkBIAb9iQH9kQEhByAF/YoBIAb9igH9kQEhCCAEIAcgB/26Af2uASEEIAQgCCAI/boB/a4BIQQgA0EQaiEDDAALCyAE/RsAIAT9GwFqIAT9GwIgBP0bA2pqIQkCQANAIAMgAk8NASAAIANqLQAAIAEgA2otAABrIQogCSAKIApsaiEJIANBAWohAwwACwsgCQs=";
+var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "AGFzbQEAAAABFQNgA39/fwF9YAJ/fwF9YAN/f38BfwISAQNlbnYGbWVtb3J5AgMBgIAEAwcGAAEAAAICB2IGC2RvdF9wcm9kdWN0AAAJbWFnbml0dWRlAAEac3F1YXJlZF9ldWNsaWRlYW5fZGlzdGFuY2UAAhJldWNsaWRlYW5fZGlzdGFuY2UAAwZkb3RfdTgABAlzcWRpc3RfdTgABQqvBwauAQQBfwF7AX0BfyACQXxxIQb9DAAAAAAAAAAAAAAAAAAAAAAhBEEAIQMCQANAIAMgBk8NASAEIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eYB/eQBIQQgA0EEaiEDDAALCyAE/R8AIAT9HwGSIAT9HwIgBP0fA5KSIQUCQANAIAMgAk8NASAFIAAgA0ECdGoqAgAgASADQQJ0aioCAJSSIQUgA0EBaiEDDAALCyAFC6kBBAF/AnsBfQF/IAFBfHEhBv0MAAAAAAAAAAAAAAAAAAAAACEDQQAhAgJAA0AgAiAGTw0BIAAgAkECdGr9AAQAIQQgAyAEIAT95gH95AEhAyACQQRqIQIMAAsLIAP9HwAgA/0fAZIgA/0fAiAD/R8DkpIhBQJAA0AgAiABTw0BIAUgACACQQJ0aioCACAAIAJBAnRqKgIAlJIhBSACQQFqIQIMAAsLIAWRC8ABBQF/AnsBfQF/AX0gAkF8cSEH/QwAAAAAAAAAAAAAAAAAAAAAIQRBACEDAkADQCADIAdPDQEgACADQQJ0av0ABAAgASADQQJ0av0ABAD95QEhBSAEIAUgBf3mAf3kASEEIANBBGohAwwACwsgBP0fACAE/R8BkiAE/R8CIAT9HwOSkiEGAkADQCADIAJPDQEgACADQQJ0aioCACABIANBAnRqKgIAkyEIIAYgCCAIlJIhBiADQQFqIQMMAAsLIAYLCwAgACABIAIQApELtAEDAX8DewJ/IAJBcHEhCEEA/REhBEEAIQMCQANAIAMgCE8NASAAIANq/QAEACEFIAEgA2r9AAQAIQYgBCAF/YkBIAb9iQH9ugH9rgEhBCAEIAX9igEgBv2KAf26Af2uASEEIANBEGohAwwACwsgBP0bACAE/RsBaiAE/RsCIAT9GwNqaiEHAkADQCADIAJPDQEgByAAIANqLQAAIAEgA2otAABsaiEHIANBAWohAwwACwsgBwvNAQMBfwV7A38gAkFwcSELQQD9ESEEQQAhAwJAA0AgAyALTw0BIAAgA2r9AAQAIQUgASADav0ABAAhBiAF/YkBIAb9iQH9kQEhByAF/YoBIAb9igH9kQEhCCAEIAcgB/26Af2uASEEIAQgCCAI/boB/a4BIQQgA0EQaiEDDAALCyAE/RsAIAT9GwFqIAT9GwIgBP0bA2pqIQkCQANAIAMgAk8NASAAIANqLQAAIAEgA2otAABrIQogCSAKIApsaiEJIANBAWohAwwACwsgCQs=";
 
 // src/vector/simd.ts
 var wasmExports = null;
@@ -97,7 +100,7 @@ function createArenaSimd() {
     if (module === null) return null;
     const instance = new WebAssembly.Instance(module);
     const exports$1 = instance.exports;
-    if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
+    if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
       return null;
     }
     return exports$1;
@@ -105,6 +108,88 @@ function createArenaSimd() {
     return null;
   }
 }
+var sharedMemoryModule;
+function getSharedMemoryModule() {
+  if (sharedMemoryModule !== void 0) return sharedMemoryModule;
+  try {
+    const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
+    const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
+      sharedMemoryModule = null;
+      return null;
+    }
+    sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
+  } catch {
+    sharedMemoryModule = null;
+  }
+  return sharedMemoryModule;
+}
+function createSharedArenaSimd(memory) {
+  try {
+    const module = getSharedMemoryModule();
+    if (module === null) return null;
+    const instance = new WebAssembly.Instance(module, { env: { memory } });
+    const exports$1 = instance.exports;
+    if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
+      return null;
+    }
+    return {
+      memory,
+      dot_product: exports$1.dot_product,
+      magnitude: exports$1.magnitude,
+      squared_euclidean_distance: exports$1.squared_euclidean_distance,
+      dot_u8: exports$1.dot_u8,
+      sqdist_u8: exports$1.sqdist_u8
+    };
+  } catch {
+    return null;
+  }
+}
+function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
+  if (metric === "euclidean") {
+    return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
+  }
+  const dot = simd.dot_product(byteA, byteB, dimension);
+  if (metric === "dotProduct") return -dot;
+  if (magnitudeA === 0 || magnitudeB === 0) return 1;
+  return 1 - dot / (magnitudeA * magnitudeB);
+}
+
+// src/vector/ordinal-filter.ts
+function createOrdinalFilter(slots) {
+  return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
+}
+function addToOrdinalFilter(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return;
+  const bit = 1 << (ordinal & 7);
+  if ((filter.bits[index] & bit) !== 0) return;
+  filter.bits[index] |= bit;
+  filter.count += 1;
+}
+function ordinalFilterHas(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return false;
+  return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
+}
+function removeFromOrdinalFilter(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return;
+  const bit = 1 << (ordinal & 7);
+  if ((filter.bits[index] & bit) === 0) return;
+  filter.bits[index] &= ~bit;
+  filter.count -= 1;
+}
+function* ordinalFilterValues(filter) {
+  const bits = filter.bits;
+  for (let index = 0; index < bits.length; index++) {
+    const byte = bits[index];
+    if (byte === 0) continue;
+    for (let offset = 0; offset < 8; offset++) {
+      if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
+    }
+  }
+}
 
 // src/vector/similarity.ts
 function magnitude(v) {
@@ -140,22 +225,30 @@ function euclideanDistance(a, b) {
   return Math.sqrt(sum);
 }
 
-// src/vector/vector-store.ts
+// src/vector/vector-store/index.ts
 var INITIAL_CAPACITY = 16;
 var PAGE_BYTES = 65536;
+var UNKNOWN_PARTITION = -1;
+var NO_PARTITION = -2;
 function createVectorStore() {
   const docToOrd = /* @__PURE__ */ new Map();
   const recycledOrds = /* @__PURE__ */ new Map();
   const ordToDoc = [];
+  let partitionOf = new Int32Array(0);
+  let unknownPartitions = 0;
   let simd = createArenaSimd();
   let dimension = 0;
   let capacity = 0;
   let arena = new Float32Array(0);
   let mags = new Float64Array(0);
   let liveCount = 0;
+  let scratchByteLength = 0;
+  let scratchFloatLength = 0;
   function initStorage(dim) {
     dimension = dim;
     if (simd) {
+      scratchByteLength = Math.max(16, Math.ceil(dim * 4 / 16) * 16);
+      scratchFloatLength = scratchByteLength / 4;
       arena = new Float32Array(simd.memory.buffer);
     }
   }
@@ -167,16 +260,18 @@ function createVectorStore() {
     nextMags.set(mags);
     mags = nextMags;
     if (simd) {
-      const requiredBytes = newCap * dimension * 4;
+      const requiredBytes = scratchByteLength + newCap * dimension * 4;
       const have = simd.memory.buffer.byteLength;
       if (requiredBytes > have) {
         try {
           simd.memory.grow(Math.ceil((requiredBytes - have) / PAGE_BYTES));
         } catch {
           const migrated = new Float32Array(newCap * dimension);
-          migrated.set(arena.subarray(0, capacity * dimension));
+          migrated.set(arena.subarray(scratchFloatLength, scratchFloatLength + capacity * dimension));
           arena = migrated;
           simd = null;
+          scratchByteLength = 0;
+          scratchFloatLength = 0;
           capacity = newCap;
           return;
         }
@@ -190,22 +285,48 @@ function createVectorStore() {
     capacity = newCap;
   }
   function writeVector(ord, vector) {
-    arena.set(vector, ord * dimension);
+    arena.set(vector, scratchFloatLength + ord * dimension);
     mags[ord] = magnitude(vector);
   }
   function entryAt(ord) {
-    const base = ord * dimension;
+    const base = scratchFloatLength + ord * dimension;
     return { vector: arena.subarray(base, base + dimension), magnitude: mags[ord] };
   }
+  function ensurePartitionSlots(ord) {
+    if (ord < partitionOf.length) return;
+    let length = partitionOf.length === 0 ? INITIAL_CAPACITY : partitionOf.length;
+    while (length <= ord) length *= 2;
+    const grown = new Int32Array(length).fill(UNKNOWN_PARTITION);
+    grown.set(partitionOf);
+    partitionOf = grown;
+  }
+  function recordPartition(ord, partitionId, wasLive) {
+    ensurePartitionSlots(ord);
+    const previous = partitionOf[ord];
+    const given = partitionId !== void 0 && partitionId >= 0 ? partitionId : void 0;
+    const next = given ?? (wasLive ? previous : UNKNOWN_PARTITION);
+    partitionOf[ord] = next;
+    if (!wasLive && next === UNKNOWN_PARTITION) {
+      unknownPartitions += 1;
+      return;
+    }
+    if (wasLive && previous === UNKNOWN_PARTITION && next !== UNKNOWN_PARTITION) {
+      unknownPartitions -= 1;
+    }
+  }
   return {
     get size() {
       return liveCount;
     },
-    insert(docId, vector) {
+    get slots() {
+      return ordToDoc.length;
+    },
+    insert(docId, vector, partitionId) {
       if (dimension === 0) initStorage(vector.length);
       const existing = docToOrd.get(docId);
       if (existing !== void 0) {
         writeVector(existing, vector);
+        recordPartition(existing, partitionId, true);
         return;
       }
       const recycled = recycledOrds.get(docId);
@@ -215,6 +336,7 @@ function createVectorStore() {
         ordToDoc[recycled] = docId;
         ensureCapacity2(recycled + 1);
         writeVector(recycled, vector);
+        recordPartition(recycled, partitionId, false);
         liveCount++;
         return;
       }
@@ -223,14 +345,59 @@ function createVectorStore() {
       ordToDoc.push(docId);
       ensureCapacity2(ord + 1);
       writeVector(ord, vector);
+      recordPartition(ord, partitionId, false);
       liveCount++;
     },
+    setPartition(docId, partitionId) {
+      const ord = docToOrd.get(docId);
+      if (ord === void 0) return;
+      recordPartition(ord, partitionId, true);
+    },
+    forgetPartition(docId) {
+      const ord = docToOrd.get(docId);
+      if (ord === void 0 || ord >= partitionOf.length) return;
+      if (partitionOf[ord] === UNKNOWN_PARTITION) {
+        unknownPartitions -= 1;
+      }
+      partitionOf[ord] = NO_PARTITION;
+    },
+    partitionOfOrdinal(ordinal) {
+      if (ordinal < 0 || ordinal >= partitionOf.length) return void 0;
+      const partitionId = partitionOf[ordinal];
+      return partitionId < 0 ? void 0 : partitionId;
+    },
+    get partitionsKnown() {
+      return unknownPartitions === 0;
+    },
+    partitionFilter(partitionIds) {
+      const filter = createOrdinalFilter(ordToDoc.length);
+      let highest = -1;
+      for (const partitionId of partitionIds) {
+        if (partitionId > highest) highest = partitionId;
+      }
+      if (highest < 0) return filter;
+      const wanted = new Uint8Array(highest + 1);
+      for (const partitionId of partitionIds) {
+        if (partitionId >= 0) wanted[partitionId] = 1;
+      }
+      const upperBound = Math.min(ordToDoc.length, partitionOf.length);
+      for (let ord = 0; ord < upperBound; ord++) {
+        if (ordToDoc[ord] === void 0) continue;
+        const partitionId = partitionOf[ord];
+        if (partitionId < 0 || partitionId > highest || wanted[partitionId] === 0) continue;
+        addToOrdinalFilter(filter, ord);
+      }
+      return filter;
+    },
     remove(docId) {
       const ord = docToOrd.get(docId);
       if (ord === void 0) return;
       docToOrd.delete(docId);
       ordToDoc[ord] = void 0;
       recycledOrds.set(docId, ord);
+      if (ord < partitionOf.length && partitionOf[ord] === UNKNOWN_PARTITION) {
+        unknownPartitions -= 1;
+      }
       liveCount--;
     },
     get(docId) {
@@ -251,6 +418,8 @@ function createVectorStore() {
       docToOrd.clear();
       recycledOrds.clear();
       ordToDoc.length = 0;
+      partitionOf = new Int32Array(0);
+      unknownPartitions = 0;
       mags = new Float64Array(0);
       if (!simd) {
         arena = new Float32Array(0);
@@ -258,6 +427,8 @@ function createVectorStore() {
       dimension = 0;
       capacity = 0;
       liveCount = 0;
+      scratchByteLength = 0;
+      scratchFloatLength = 0;
     },
     getOrdinal(docId) {
       return docToOrd.get(docId);
@@ -272,20 +443,12 @@ function createVectorStore() {
     distanceByOrdinal(ordA, ordB, metric) {
       if (ordToDoc[ordA] === void 0 || ordToDoc[ordB] === void 0) return Number.POSITIVE_INFINITY;
       if (simd) {
-        const byteA = ordA * dimension * 4;
-        const byteB = ordB * dimension * 4;
-        if (metric === "euclidean") {
-          return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
-        }
-        const dot = simd.dot_product(byteA, byteB, dimension);
-        if (metric === "dotProduct") return -dot;
-        const magA = mags[ordA];
-        const magB = mags[ordB];
-        if (magA === 0 || magB === 0) return 1;
-        return 1 - dot / (magA * magB);
+        const byteA = scratchByteLength + ordA * dimension * 4;
+        const byteB = scratchByteLength + ordB * dimension * 4;
+        return arenaFloat32Distance(simd, byteA, byteB, dimension, metric, mags[ordA], mags[ordB]);
       }
-      const baseA = ordA * dimension;
-      const baseB = ordB * dimension;
+      const baseA = scratchFloatLength + ordA * dimension;
+      const baseB = scratchFloatLength + ordB * dimension;
       const a = arena.subarray(baseA, baseA + dimension);
       const b = arena.subarray(baseB, baseB + dimension);
       switch (metric) {
@@ -297,6 +460,68 @@ function createVectorStore() {
           return euclideanDistance(a, b);
       }
     },
+    prepareQueryArena(query) {
+      if (!simd || dimension === 0 || query.length !== dimension) return null;
+      arena.set(query, 0);
+      return { magnitude: simd.magnitude(0, dimension) };
+    },
+    distanceFromArena(prepared, ordinal, metric) {
+      if (!simd || ordinal < 0 || ordinal >= ordToDoc.length || ordToDoc[ordinal] === void 0) {
+        return Number.POSITIVE_INFINITY;
+      }
+      const byteOffset = scratchByteLength + ordinal * dimension * 4;
+      return arenaFloat32Distance(simd, 0, byteOffset, dimension, metric, prepared.magnitude, mags[ordinal]);
+    },
+    exportSnapshot() {
+      const slots = ordToDoc.length;
+      const vectors = new Float32Array(slots * dimension);
+      if (slots > 0 && dimension > 0) {
+        vectors.set(arena.subarray(scratchFloatLength, scratchFloatLength + slots * dimension));
+      }
+      const magnitudes = new Float64Array(slots);
+      magnitudes.set(mags.subarray(0, Math.min(slots, mags.length)));
+      const docIds = new Array(slots);
+      for (let ord = 0; ord < slots; ord++) {
+        docIds[ord] = ordToDoc[ord] ?? null;
+      }
+      return { dimension, slots, vectors, magnitudes, docIds };
+    },
+    copySnapshotInto(vectors, magnitudes) {
+      const slots = ordToDoc.length;
+      if (slots > 0 && dimension > 0) {
+        vectors.set(arena.subarray(scratchFloatLength, scratchFloatLength + slots * dimension));
+      }
+      magnitudes.set(mags.subarray(0, Math.min(slots, mags.length)));
+    },
+    restoreSnapshot(snapshot) {
+      docToOrd.clear();
+      recycledOrds.clear();
+      ordToDoc.length = 0;
+      partitionOf = new Int32Array(0);
+      unknownPartitions = 0;
+      liveCount = 0;
+      capacity = 0;
+      dimension = 0;
+      scratchByteLength = 0;
+      scratchFloatLength = 0;
+      if (!simd) {
+        arena = new Float32Array(0);
+      }
+      if (snapshot.dimension === 0 || snapshot.slots === 0) return;
+      initStorage(snapshot.dimension);
+      ensureCapacity2(snapshot.slots);
+      arena.set(snapshot.vectors.subarray(0, snapshot.slots * snapshot.dimension), scratchFloatLength);
+      mags.set(snapshot.magnitudes.subarray(0, Math.min(snapshot.slots, mags.length)));
+      ensurePartitionSlots(snapshot.slots);
+      for (let ord = 0; ord < snapshot.slots; ord++) {
+        const docId = snapshot.docIds[ord];
+        ordToDoc.push(docId ?? void 0);
+        if (docId === null || docId === void 0) continue;
+        docToOrd.set(docId, ord);
+        unknownPartitions += 1;
+        liveCount++;
+      }
+    },
     estimateMemory(dimension2) {
       const count = liveCount;
       if (count === 0) return 0;
@@ -395,12 +620,201 @@ function createHeap(compare) {
   };
 }
 
-// src/vector/hnsw/shared.ts
+// src/vector/hnsw/adjacency.ts
 var MAX_LAYER_CAP = 32;
+var MAX_M = 512;
+var ABSENT = -1;
+var INITIAL_UPPER_SLOTS = 64;
+function createAdjacency(m, mMax0) {
+  return {
+    m,
+    mMax0,
+    level0Stride: mMax0 + 2,
+    upperStride: m + 2,
+    capacity: 0,
+    slots: 0,
+    nodeLevels: new Int8Array(0),
+    level0: new Int32Array(0),
+    upperBase: new Int32Array(0),
+    upper: new Int32Array(0),
+    upperUsed: 0,
+    freeBlocks: Array.from({ length: MAX_LAYER_CAP + 1 }, () => [])
+  };
+}
+function ensureAdjacencyCapacity(adj, needed) {
+  if (needed <= adj.capacity) return;
+  let newCapacity = adj.capacity === 0 ? 16 : adj.capacity;
+  while (newCapacity < needed) newCapacity *= 2;
+  const nextLevels = new Int8Array(newCapacity).fill(ABSENT);
+  nextLevels.set(adj.nodeLevels);
+  adj.nodeLevels = nextLevels;
+  const nextLevel0 = new Int32Array(newCapacity * adj.level0Stride);
+  nextLevel0.set(adj.level0);
+  adj.level0 = nextLevel0;
+  const nextUpperBase = new Int32Array(newCapacity).fill(ABSENT);
+  nextUpperBase.set(adj.upperBase);
+  adj.upperBase = nextUpperBase;
+  adj.capacity = newCapacity;
+}
+function allocateUpperBlock(adj, levels) {
+  const reusable = adj.freeBlocks[levels].pop();
+  const size = levels * adj.upperStride;
+  if (reusable !== void 0) {
+    adj.upper.fill(0, reusable, reusable + size);
+    return reusable;
+  }
+  if (adj.upperUsed + size > adj.upper.length) {
+    const required = adj.upperUsed + size;
+    let nextLength = adj.upper.length === 0 ? INITIAL_UPPER_SLOTS * adj.upperStride : adj.upper.length;
+    while (nextLength < required) nextLength *= 2;
+    const nextUpper = new Int32Array(nextLength);
+    nextUpper.set(adj.upper);
+    adj.upper = nextUpper;
+  }
+  const offset = adj.upperUsed;
+  adj.upperUsed += size;
+  adj.upper.fill(0, offset, offset + size);
+  return offset;
+}
+function createNode(adj, ord, maxLayer) {
+  ensureAdjacencyCapacity(adj, ord + 1);
+  if (ord >= adj.slots) adj.slots = ord + 1;
+  const existingLevel = adj.nodeLevels[ord];
+  const existingBase = adj.upperBase[ord];
+  if (existingLevel >= 1 && existingBase !== ABSENT) {
+    adj.freeBlocks[existingLevel].push(existingBase);
+  }
+  adj.nodeLevels[ord] = maxLayer;
+  adj.level0[ord * adj.level0Stride] = 0;
+  adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) : ABSENT;
+}
+function deleteNode(adj, ord) {
+  if (ord < 0 || ord >= adj.capacity) return;
+  const level = adj.nodeLevels[ord];
+  const base = adj.upperBase[ord];
+  if (level >= 1 && base !== ABSENT) {
+    adj.freeBlocks[level].push(base);
+  }
+  adj.nodeLevels[ord] = ABSENT;
+  adj.upperBase[ord] = ABSENT;
+  adj.level0[ord * adj.level0Stride] = 0;
+}
+function resetAdjacency(adj) {
+  adj.nodeLevels = new Int8Array(0);
+  adj.level0 = new Int32Array(0);
+  adj.upperBase = new Int32Array(0);
+  adj.upper = new Int32Array(0);
+  adj.upperUsed = 0;
+  adj.capacity = 0;
+  adj.slots = 0;
+  for (const list of adj.freeBlocks) list.length = 0;
+}
+function nodeLevel(adj, ord) {
+  if (ord < 0 || ord >= adj.capacity) return ABSENT;
+  return adj.nodeLevels[ord];
+}
+function hasNode(adj, ord) {
+  return nodeLevel(adj, ord) !== ABSENT;
+}
+function layerArray(adj, layer) {
+  return layer === 0 ? adj.level0 : adj.upper;
+}
+function layerBase(adj, ord, layer) {
+  const level = nodeLevel(adj, ord);
+  if (level === ABSENT || layer > level) return ABSENT;
+  if (layer === 0) return ord * adj.level0Stride;
+  const base = adj.upperBase[ord];
+  if (base === ABSENT) return ABSENT;
+  return base + (layer - 1) * adj.upperStride;
+}
+function neighborCount(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return 0;
+  return layerArray(adj, layer)[base];
+}
+function collectNeighbors(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return [];
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  const collected = new Array(count);
+  for (let i = 0; i < count; i++) {
+    collected[i] = array[base + i + 1];
+  }
+  return collected;
+}
+function addNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] === neighborOrd) return;
+  }
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  if (count + 1 > stride - 1) return;
+  array[base + count + 1] = neighborOrd;
+  array[base] = count + 1;
+}
+function removeNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] !== neighborOrd) continue;
+    for (let j = i; j < count; j++) {
+      array[base + j] = array[base + j + 1];
+    }
+    array[base] = count - 1;
+    return;
+  }
+}
+function replaceNeighbors(adj, ord, layer, neighbors) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  const limit = Math.min(neighbors.length, stride - 1);
+  for (let i = 0; i < limit; i++) {
+    array[base + i + 1] = neighbors[i];
+  }
+  array[base] = limit;
+}
+function exportAdjacency(adj) {
+  return {
+    m: adj.m,
+    mMax0: adj.mMax0,
+    capacity: adj.capacity,
+    slots: adj.slots,
+    upperUsed: adj.upperUsed,
+    nodeLevels: adj.nodeLevels.slice(),
+    level0: adj.level0.slice(),
+    upperBase: adj.upperBase.slice(),
+    upper: adj.upper.slice(0, adj.upperUsed)
+  };
+}
+function importAdjacency(snapshot) {
+  const adj = createAdjacency(snapshot.m, snapshot.mMax0);
+  adj.capacity = snapshot.capacity;
+  adj.slots = snapshot.slots;
+  adj.upperUsed = snapshot.upperUsed;
+  adj.nodeLevels = snapshot.nodeLevels;
+  adj.level0 = snapshot.level0;
+  adj.upperBase = snapshot.upperBase;
+  adj.upper = snapshot.upper;
+  return adj;
+}
+function estimateAdjacencyBytes(adj) {
+  return adj.nodeLevels.byteLength + adj.level0.byteLength + adj.upperBase.byteLength + adj.upper.byteLength;
+}
+
+// src/vector/hnsw/shared.ts
 var COMPACTION_TOMBSTONE_RATIO = 0.1;
 var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
 var SQ8_OVERSELECTION_FACTOR = 2;
 function ensureCapacity(state, needed) {
+  ensureAdjacencyCapacity(state.adjacency, needed);
   if (needed <= state.capacity) return;
   let newCap = state.capacity === 0 ? 16 : state.capacity;
   while (newCap < needed) newCap *= 2;
@@ -419,6 +833,12 @@ function nextVisitStamp(state) {
   }
   return state.visitStamp;
 }
+function nodeExists(state, ord) {
+  return hasNode(state.adjacency, ord);
+}
+function nodeMaxLayer(state, ord) {
+  return nodeLevel(state.adjacency, ord);
+}
 function toDistance(a, b, magA, magB, metric) {
   switch (metric) {
     case "cosine":
@@ -470,6 +890,8 @@ function addConnection(connections, ord) {
 // src/vector/hnsw/graph-ops.ts
 function searchLayer(state, qVec, qMag, eps, ef, layer, metric, skipTombstones, distFn) {
   const getDistance = distFn ?? ((ord) => queryDistanceByOrd(state, qVec, qMag, ord, metric));
+  const adjacency = state.adjacency;
+  const neighbors = layerArray(adjacency, layer);
   const visited = state.visited;
   const stamp = nextVisitStamp(state);
   const candidates = createMinHeap(distanceAsc);
@@ -478,8 +900,7 @@ function searchLayer(state, qVec, qMag, eps, ef, layer, metric, skipTombstones,
   for (const epOrd of eps) {
     if (visited[epOrd] === stamp) continue;
     visited[epOrd] = stamp;
-    const node = state.nodesByOrd[epOrd];
-    if (!node) continue;
+    if (!nodeExists(state, epOrd)) continue;
     if (skipTombstones && state.tombstones[epOrd] === 1) continue;
     const dist = getDistance(epOrd);
     if (dist === Number.POSITIVE_INFINITY) continue;
@@ -496,14 +917,15 @@ function searchLayer(state, qVec, qMag, eps, ef, layer, metric, skipTombstones,
     const nearest = candidates.pop();
     if (!nearest) break;
     if (nearest.distance > furthestDist) break;
-    const node = state.nodesByOrd[nearest.ord];
-    if (!node || layer >= node.connections.length) continue;
-    for (const neighborOrd of node.connections[layer]) {
+    const base = layerBase(adjacency, nearest.ord, layer);
+    if (base === -1) continue;
+    const count = neighbors[base];
+    for (let i = 1; i <= count; i++) {
+      const neighborOrd = neighbors[base + i];
       if (visited[neighborOrd] === stamp) continue;
       visited[neighborOrd] = stamp;
       if (skipTombstones && state.tombstones[neighborOrd] === 1) continue;
-      const neighborNode = state.nodesByOrd[neighborOrd];
-      if (!neighborNode) continue;
+      if (!nodeExists(state, neighborOrd)) continue;
       const dist = getDistance(neighborOrd);
       if (dist === Number.POSITIVE_INFINITY) continue;
       if (dist < furthestDist || results.size < ef) {
@@ -557,12 +979,16 @@ function selectNeighborsHeuristic(state, targetOrd, candidates, maxConnections,
   return selected;
 }
 function pruneConnections(state, ord, layer, metric) {
-  const node = state.nodesByOrd[ord];
-  if (!node) return;
+  const adjacency = state.adjacency;
+  const base = layerBase(adjacency, ord, layer);
+  if (base === -1) return;
   const mc = maxConns(state, layer);
-  if (node.connections[layer].length <= mc) return;
+  const neighbors = layerArray(adjacency, layer);
+  const count = neighbors[base];
+  if (count <= mc) return;
   const conns = [];
-  for (const connOrd of node.connections[layer]) {
+  for (let i = 1; i <= count; i++) {
+    const connOrd = neighbors[base + i];
     const dist = nodeDistanceByOrd(state, ord, connOrd, metric);
     if (dist === Number.POSITIVE_INFINITY) continue;
     conns.push({ ord: connOrd, distance: dist });
@@ -570,14 +996,131 @@ function pruneConnections(state, ord, layer, metric) {
   const pruned = selectNeighborsHeuristic(state, ord, conns, mc, layer, metric);
   const next = [];
   for (const p of pruned) addConnection(next, p.ord);
-  node.connections[layer] = next;
+  replaceNeighbors(adjacency, ord, layer, next);
 }
 
-// src/vector/hnsw/mutation.ts
-function removeFromArray(arr, ord) {
-  const idx = arr.indexOf(ord);
-  if (idx !== -1) arr.splice(idx, 1);
+// src/vector/hnsw/search.ts
+var ABSENT_DOCUMENT_RANK = 4294967295;
+function collectHits(state, query, k, searchMetric, minSimilarity, filter, efSearch, hasDocument) {
+  if (query.length !== state.dimension) {
+    throw new Error(`Query dimension mismatch: expected ${state.dimension}, got ${query.length}`);
+  }
+  const liveSize = state.nodeCount - state.tombstoneCount;
+  if (state.entryPointOrd === -1 || liveSize === 0) {
+    return [];
+  }
+  const useQuantized = state.quantizer?.isCalibrated() === true && state.quantizer.size > 0;
+  const defaultEf = 50;
+  let ef = Math.max(efSearch ?? defaultEf, k);
+  if (filter && filter.count < liveSize) {
+    const selectivity = filter.count / liveSize;
+    ef = Math.max(ef, Math.ceil(k / Math.max(selectivity, 0.01)));
+    ef = Math.min(ef, liveSize);
+  }
+  const store = state.store;
+  const arenaQuery = store.prepareQueryArena(query);
+  const qMag = arenaQuery ? arenaQuery.magnitude : magnitude(query);
+  let quantizedDistFn;
+  if (useQuantized && state.quantizer) {
+    const q = state.quantizer;
+    const metric = searchMetric;
+    const quantizedArenaQuery = q.prepareQueryArena(query);
+    if (quantizedArenaQuery) {
+      quantizedDistFn = (ord) => q.distanceFromArena(quantizedArenaQuery, ord, metric);
+    } else {
+      const prepared = q.prepareQuery(query);
+      if (prepared) {
+        quantizedDistFn = (ord) => q.distanceFromPreparedByOrdinal(prepared, ord, metric);
+      }
+    }
+  }
+  let distFn = quantizedDistFn;
+  if (!distFn && arenaQuery) {
+    const metric = searchMetric;
+    distFn = (ord) => store.distanceFromArena(arenaQuery, ord, metric);
+  }
+  let currentEPs = [state.entryPointOrd];
+  for (let layer = state.topLayer; layer >= 1; layer--) {
+    const heap = searchLayer(state, query, qMag, currentEPs, 1, layer, searchMetric, true, distFn);
+    const nearest = nearestFromHeap(heap);
+    if (nearest) {
+      currentEPs = [nearest.ord];
+    }
+  }
+  const candidateHeap = searchLayer(state, query, qMag, currentEPs, ef, 0, searchMetric, true, distFn);
+  const candidateArray = candidateHeap.toSortedArray().reverse();
+  if (useQuantized) {
+    return rerankWithFullPrecision(
+      state,
+      candidateArray,
+      query,
+      qMag,
+      arenaQuery,
+      k,
+      searchMetric,
+      minSimilarity,
+      filter,
+      hasDocument
+    );
+  }
+  const hits = [];
+  for (const cand of candidateArray) {
+    if (filter && !ordinalFilterHas(filter, cand.ord)) continue;
+    const score = toScore(cand.distance, searchMetric);
+    if (score < minSimilarity) continue;
+    if (!hasDocument(cand.ord)) continue;
+    hits.push({ ord: cand.ord, score });
+  }
+  return hits;
+}
+function rerankWithFullPrecision(state, candidates, query, qMag, arenaQuery, k, metric, minSimilarity, filter, hasDocument) {
+  const reranked = [];
+  const rerankLimit = Math.max(k * SQ8_OVERSELECTION_FACTOR, 10);
+  for (const cand of candidates) {
+    if (filter && !ordinalFilterHas(filter, cand.ord)) continue;
+    let fullDistance;
+    if (arenaQuery) {
+      fullDistance = state.store.distanceFromArena(arenaQuery, cand.ord, metric);
+      if (fullDistance === Number.POSITIVE_INFINITY) continue;
+    } else {
+      const entry = entryForOrd(state, cand.ord);
+      if (!entry) continue;
+      fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
+    }
+    const score = toScore(fullDistance, metric);
+    if (score < minSimilarity) continue;
+    if (!hasDocument(cand.ord)) continue;
+    reranked.push({ ord: cand.ord, score });
+    if (reranked.length >= rerankLimit) break;
+  }
+  return reranked;
 }
+function search(state, query, k, searchMetric, minSimilarity, filter, efSearch) {
+  const hasDocument = (ord) => state.store.docIdForOrdinal(ord) !== void 0;
+  const hits = collectHits(state, query, k, searchMetric, minSimilarity, filter, efSearch, hasDocument);
+  const results = [];
+  for (const hit of hits) {
+    const docId = state.store.docIdForOrdinal(hit.ord);
+    if (docId === void 0) continue;
+    results.push({
+      docId,
+      score: hit.score,
+      termFrequencies: {},
+      fieldLengths: {},
+      idf: {}
+    });
+  }
+  results.sort((a, b) => b.score - a.score || compareCodePoints(a.docId, b.docId));
+  return results.slice(0, k);
+}
+function searchOrdinals(state, query, k, searchMetric, minSimilarity, rankByOrdinal, filter, efSearch) {
+  const hasDocument = (ord) => ord < rankByOrdinal.length && rankByOrdinal[ord] !== ABSENT_DOCUMENT_RANK;
+  const hits = collectHits(state, query, k, searchMetric, minSimilarity, filter, efSearch, hasDocument);
+  hits.sort((a, b) => b.score - a.score || rankByOrdinal[a.ord] - rankByOrdinal[b.ord]);
+  return hits.slice(0, k);
+}
+
+// src/vector/hnsw/mutation.ts
 function clearTombstone(state, ord) {
   if (state.tombstones[ord] === 1) {
     state.tombstones[ord] = 0;
@@ -587,21 +1130,21 @@ function clearTombstone(state, ord) {
 function reassignEntryPoint(state) {
   let bestOrd = -1;
   let bestLayer = -1;
-  for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-    const n = state.nodesByOrd[ord];
-    if (!n) continue;
+  for (let ord = 0; ord < state.adjacency.slots; ord++) {
+    const level = nodeMaxLayer(state, ord);
+    if (level === -1) continue;
     if (state.tombstones[ord] === 1) continue;
-    if (n.maxLayer > bestLayer) {
-      bestLayer = n.maxLayer;
+    if (level > bestLayer) {
+      bestLayer = level;
       bestOrd = ord;
     }
   }
   if (bestOrd === -1) {
-    for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-      const n = state.nodesByOrd[ord];
-      if (!n) continue;
-      if (n.maxLayer > bestLayer) {
-        bestLayer = n.maxLayer;
+    for (let ord = 0; ord < state.adjacency.slots; ord++) {
+      const level = nodeMaxLayer(state, ord);
+      if (level === -1) continue;
+      if (level > bestLayer) {
+        bestLayer = level;
         bestOrd = ord;
       }
     }
@@ -622,16 +1165,12 @@ function insertNode(state, docId) {
     throw new Error(`Vector dimension mismatch: expected ${state.dimension}, got ${entry.vector.length}`);
   }
   ensureCapacity(state, ord + 1);
-  if (state.nodesByOrd[ord] !== void 0) {
+  if (nodeExists(state, ord)) {
     removeNodeEager(state, ord);
   }
   clearTombstone(state, ord);
   const l = randomLevel(state.mL);
-  const node = {
-    maxLayer: l,
-    connections: Array.from({ length: l + 1 }, () => [])
-  };
-  state.nodesByOrd[ord] = node;
+  createNode(state.adjacency, ord, l);
   state.nodeCount++;
   if (state.entryPointOrd === -1) {
     state.entryPointOrd = ord;
@@ -664,10 +1203,9 @@ function insertNode(state, docId) {
     const mc = maxConns(state, layer);
     const neighbors = selectNeighborsHeuristic(state, ord, candidates, mc, layer, metric);
     for (const neighbor of neighbors) {
-      addConnection(node.connections[layer], neighbor.ord);
-      const neighborNode = state.nodesByOrd[neighbor.ord];
-      if (neighborNode && layer < neighborNode.connections.length) {
-        addConnection(neighborNode.connections[layer], ord);
+      addNeighbor(state.adjacency, ord, layer, neighbor.ord);
+      if (layer <= nodeMaxLayer(state, neighbor.ord)) {
+        addNeighbor(state.adjacency, neighbor.ord, layer, ord);
         pruneConnections(state, neighbor.ord, layer, metric);
       }
     }
@@ -681,24 +1219,21 @@ function insertNode(state, docId) {
   }
 }
 function removeNodeEager(state, ord, excludeOrds) {
-  const node = state.nodesByOrd[ord];
-  if (!node) return;
+  const maxLayer = nodeMaxLayer(state, ord);
+  if (maxLayer === -1) return;
   const metric = state.buildMetric;
-  for (let layer = 0; layer <= node.maxLayer; layer++) {
-    if (layer >= node.connections.length) continue;
-    const formerNeighbors = [...node.connections[layer]];
+  for (let layer = 0; layer <= maxLayer; layer++) {
+    const formerNeighbors = collectNeighbors(state.adjacency, ord, layer);
     for (const neighborOrd of formerNeighbors) {
-      const neighborNode = state.nodesByOrd[neighborOrd];
-      if (neighborNode && layer < neighborNode.connections.length) {
-        removeFromArray(neighborNode.connections[layer], ord);
+      if (layer <= nodeMaxLayer(state, neighborOrd)) {
+        removeNeighbor(state.adjacency, neighborOrd, layer, ord);
       }
     }
     for (const neighborOrd of formerNeighbors) {
-      const neighborNode = state.nodesByOrd[neighborOrd];
-      if (!neighborNode || layer >= neighborNode.connections.length) continue;
+      if (layer > nodeMaxLayer(state, neighborOrd)) continue;
       const mc = maxConns(state, layer);
-      if (neighborNode.connections[layer].length >= mc) continue;
-      const candidateOrds = new Set(neighborNode.connections[layer]);
+      if (neighborCount(state.adjacency, neighborOrd, layer) >= mc) continue;
+      const candidateOrds = new Set(collectNeighbors(state.adjacency, neighborOrd, layer));
       for (const otherOrd of formerNeighbors) {
         if (otherOrd !== neighborOrd && otherOrd !== ord) {
           if (excludeOrds?.has(otherOrd)) continue;
@@ -714,17 +1249,16 @@ function removeNodeEager(state, ord, excludeOrds) {
       const selected = selectNeighborsHeuristic(state, neighborOrd, candidates, mc, layer, metric);
       const newConns = [];
       for (const s of selected) addConnection(newConns, s.ord);
-      neighborNode.connections[layer] = newConns;
+      replaceNeighbors(state.adjacency, neighborOrd, layer, newConns);
       for (const newConnOrd of newConns) {
-        const newConnNode = state.nodesByOrd[newConnOrd];
-        if (newConnNode && layer < newConnNode.connections.length) {
-          addConnection(newConnNode.connections[layer], neighborOrd);
+        if (layer <= nodeMaxLayer(state, newConnOrd)) {
+          addNeighbor(state.adjacency, newConnOrd, layer, neighborOrd);
           pruneConnections(state, newConnOrd, layer, metric);
         }
       }
     }
   }
-  state.nodesByOrd[ord] = void 0;
+  deleteNode(state.adjacency, ord);
   state.nodeCount--;
   clearTombstone(state, ord);
   if (state.entryPointOrd === ord) {
@@ -738,7 +1272,7 @@ function removeNodeEager(state, ord, excludeOrds) {
 }
 function markTombstone(state, docId) {
   const ord = state.store.getOrdinal(docId);
-  if (ord === void 0 || state.nodesByOrd[ord] === void 0) return;
+  if (ord === void 0 || !nodeExists(state, ord)) return;
   if (state.tombstones[ord] === 0) {
     state.tombstones[ord] = 1;
     state.tombstoneCount++;
@@ -746,12 +1280,12 @@ function markTombstone(state, docId) {
   if (state.entryPointOrd === ord) {
     let bestOrd = -1;
     let bestLayer = -1;
-    for (let o = 0; o < state.nodesByOrd.length; o++) {
-      const n = state.nodesByOrd[o];
-      if (!n) continue;
+    for (let o = 0; o < state.adjacency.slots; o++) {
+      const level = nodeMaxLayer(state, o);
+      if (level === -1) continue;
       if (state.tombstones[o] === 1) continue;
-      if (n.maxLayer > bestLayer) {
-        bestLayer = n.maxLayer;
+      if (level > bestLayer) {
+        bestLayer = level;
         bestOrd = o;
       }
     }
@@ -767,8 +1301,8 @@ function markTombstone(state, docId) {
 function compactTombstones(state) {
   if (state.tombstoneCount === 0) return;
   const tombstonedOrds = [];
-  for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-    if (state.tombstones[ord] === 1 && state.nodesByOrd[ord] !== void 0) {
+  for (let ord = 0; ord < state.adjacency.slots; ord++) {
+    if (state.tombstones[ord] === 1 && nodeExists(state, ord)) {
       tombstonedOrds.push(ord);
     }
   }
@@ -780,12 +1314,12 @@ function compactTombstones(state) {
 function rebuild(state) {
   if (state.tombstoneCount === 0 && state.nodeCount === 0) return;
   const liveOrds = [];
-  for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-    if (state.nodesByOrd[ord] !== void 0 && state.tombstones[ord] !== 1) {
+  for (let ord = 0; ord < state.adjacency.slots; ord++) {
+    if (nodeExists(state, ord) && state.tombstones[ord] !== 1) {
       liveOrds.push(ord);
     }
   }
-  state.nodesByOrd = [];
+  resetAdjacency(state.adjacency);
   state.tombstones.fill(0);
   state.tombstoneCount = 0;
   state.nodeCount = 0;
@@ -802,16 +1336,16 @@ function rebuild(state) {
 // src/vector/hnsw/persistence.ts
 function serializeGraph(state) {
   const nodeArray = [];
-  for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-    const node = state.nodesByOrd[ord];
-    if (!node) continue;
+  for (let ord = 0; ord < state.adjacency.slots; ord++) {
+    const maxLayer = nodeMaxLayer(state, ord);
+    if (maxLayer === -1) continue;
     if (state.tombstones[ord] === 1) continue;
     const docId = state.store.docIdForOrdinal(ord);
     if (docId === void 0) continue;
     const layerConns = [];
-    for (let layer = 0; layer < node.connections.length; layer++) {
+    for (let layer = 0; layer <= maxLayer; layer++) {
       const liveNeighbors = [];
-      for (const neighborOrd of node.connections[layer]) {
+      for (const neighborOrd of collectNeighbors(state.adjacency, ord, layer)) {
         if (state.tombstones[neighborOrd] === 1) continue;
         const neighborDoc = state.store.docIdForOrdinal(neighborOrd);
         if (neighborDoc === void 0) continue;
@@ -821,7 +1355,7 @@ function serializeGraph(state) {
         layerConns.push([layer, liveNeighbors]);
       }
     }
-    nodeArray.push([docId, node.maxLayer, layerConns]);
+    nodeArray.push([docId, maxLayer, layerConns]);
   }
   const entryPoint = state.entryPointOrd === -1 ? null : state.store.docIdForOrdinal(state.entryPointOrd) ?? null;
   return {
@@ -833,54 +1367,66 @@ function serializeGraph(state) {
     nodes: nodeArray
   };
 }
-function deserializeGraph(state, data) {
-  state.nodesByOrd = [];
-  state.tombstones.fill(0);
-  state.tombstoneCount = 0;
-  state.nodeCount = 0;
-  state.entryPointOrd = -1;
-  state.topLayer = -1;
+function resolveNodes(state, data) {
+  const nodes = [];
   let maxOrd = -1;
   for (const [docId, maxLayer, layerConns] of data.nodes) {
     const ord = state.store.getOrdinal(docId);
     if (ord === void 0) continue;
     if (state.store.entryForOrdinal(ord) === void 0) continue;
-    const connections = Array.from({ length: maxLayer + 1 }, () => []);
+    const clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
+    const layers = [];
     for (const [layer, neighbors] of layerConns) {
-      if (layer < connections.length) {
-        const arr = [];
-        for (const neighborDoc of neighbors) {
-          const neighborOrd = state.store.getOrdinal(neighborDoc);
-          if (neighborOrd === void 0) continue;
-          addConnection(arr, neighborOrd);
-          if (neighborOrd > maxOrd) maxOrd = neighborOrd;
-        }
-        connections[layer] = arr;
+      if (layer < 0 || layer > clampedMaxLayer) continue;
+      const limit = maxConns(state, layer);
+      const resolved = [];
+      for (const neighborDoc of neighbors) {
+        if (resolved.length >= limit) break;
+        const neighborOrd = state.store.getOrdinal(neighborDoc);
+        if (neighborOrd === void 0) continue;
+        addConnection(resolved, neighborOrd);
+        if (neighborOrd > maxOrd) maxOrd = neighborOrd;
       }
+      layers.push([layer, resolved]);
     }
-    const node = { maxLayer, connections };
-    state.nodesByOrd[ord] = node;
-    state.nodeCount++;
     if (ord > maxOrd) maxOrd = ord;
+    nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
   }
+  return { nodes, maxOrd };
+}
+function deserializeGraph(state, data) {
+  resetAdjacency(state.adjacency);
+  state.tombstones.fill(0);
+  state.tombstoneCount = 0;
+  state.nodeCount = 0;
+  state.entryPointOrd = -1;
+  state.topLayer = -1;
+  const { nodes, maxOrd } = resolveNodes(state, data);
   if (maxOrd >= 0) {
     ensureCapacity(state, maxOrd + 1);
   }
+  for (const node of nodes) {
+    createNode(state.adjacency, node.ord, node.maxLayer);
+    for (const [layer, neighbors] of node.layers) {
+      replaceNeighbors(state.adjacency, node.ord, layer, neighbors);
+    }
+    state.nodeCount++;
+  }
   if (data.entryPoint != null && data.entryPoint !== "") {
     const epOrd = state.store.getOrdinal(data.entryPoint);
-    if (epOrd !== void 0 && state.nodesByOrd[epOrd] !== void 0) {
+    if (epOrd !== void 0 && nodeExists(state, epOrd)) {
       state.entryPointOrd = epOrd;
-      state.topLayer = data.maxLayer;
+      state.topLayer = Math.min(Math.max(data.maxLayer, 0), MAX_LAYER_CAP);
     }
   }
   if (state.entryPointOrd === -1 && state.nodeCount > 0) {
     let bestOrd = -1;
     let bestLayer = -1;
-    for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-      const n = state.nodesByOrd[ord];
-      if (!n) continue;
-      if (n.maxLayer > bestLayer) {
-        bestLayer = n.maxLayer;
+    for (let ord = 0; ord < state.adjacency.slots; ord++) {
+      const level = nodeMaxLayer(state, ord);
+      if (level === -1) continue;
+      if (level > bestLayer) {
+        bestLayer = level;
         bestOrd = ord;
       }
     }
@@ -889,102 +1435,6 @@ function deserializeGraph(state, data) {
   }
 }
 
-// src/vector/hnsw/search.ts
-function search(state, query, k, searchMetric, minSimilarity, filterDocIds, efSearch) {
-  if (query.length !== state.dimension) {
-    throw new Error(`Query dimension mismatch: expected ${state.dimension}, got ${query.length}`);
-  }
-  const liveSize = state.nodeCount - state.tombstoneCount;
-  if (state.entryPointOrd === -1 || liveSize === 0) {
-    return [];
-  }
-  const useQuantized = state.quantizer?.isCalibrated() === true && state.quantizer.size > 0;
-  const defaultEf = 50;
-  let ef = Math.max(efSearch ?? defaultEf, k);
-  let filterOrds;
-  if (filterDocIds) {
-    filterOrds = /* @__PURE__ */ new Set();
-    for (const docId of filterDocIds) {
-      const o = state.store.getOrdinal(docId);
-      if (o !== void 0) filterOrds.add(o);
-    }
-    if (filterOrds.size < liveSize) {
-      const selectivity = filterOrds.size / liveSize;
-      ef = Math.max(ef, Math.ceil(k / Math.max(selectivity, 0.01)));
-      ef = Math.min(ef, liveSize);
-    }
-  }
-  const qMag = magnitude(query);
-  let quantizedDistFn;
-  if (useQuantized && state.quantizer) {
-    const q = state.quantizer;
-    const metric = searchMetric;
-    const arenaQuery = q.prepareQueryArena(query);
-    if (arenaQuery) {
-      quantizedDistFn = (ord) => q.distanceFromArena(arenaQuery, ord, metric);
-    } else {
-      const prepared = q.prepareQuery(query);
-      if (prepared) {
-        quantizedDistFn = (ord) => q.distanceFromPreparedByOrdinal(prepared, ord, metric);
-      }
-    }
-  }
-  let currentEPs = [state.entryPointOrd];
-  for (let layer = state.topLayer; layer >= 1; layer--) {
-    const heap = searchLayer(state, query, qMag, currentEPs, 1, layer, searchMetric, true, quantizedDistFn);
-    const nearest = nearestFromHeap(heap);
-    if (nearest) {
-      currentEPs = [nearest.ord];
-    }
-  }
-  const candidateHeap = searchLayer(state, query, qMag, currentEPs, ef, 0, searchMetric, true, quantizedDistFn);
-  const candidateArray = candidateHeap.toSortedArray().reverse();
-  if (useQuantized) {
-    return rerankWithFullPrecision(state, candidateArray, query, qMag, k, searchMetric, minSimilarity, filterOrds);
-  }
-  const results = [];
-  for (const cand of candidateArray) {
-    if (filterOrds && !filterOrds.has(cand.ord)) continue;
-    const score = toScore(cand.distance, searchMetric);
-    if (score < minSimilarity) continue;
-    const docId = state.store.docIdForOrdinal(cand.ord);
-    if (docId === void 0) continue;
-    results.push({
-      docId,
-      score,
-      termFrequencies: {},
-      fieldLengths: {},
-      idf: {}
-    });
-  }
-  results.sort((a, b) => b.score - a.score || a.docId.localeCompare(b.docId));
-  return results.slice(0, k);
-}
-function rerankWithFullPrecision(state, candidates, query, qMag, k, metric, minSimilarity, filterOrds) {
-  const reranked = [];
-  const rerankLimit = Math.max(k * SQ8_OVERSELECTION_FACTOR, 10);
-  for (const cand of candidates) {
-    if (filterOrds && !filterOrds.has(cand.ord)) continue;
-    const entry = entryForOrd(state, cand.ord);
-    if (!entry) continue;
-    const fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
-    const score = toScore(fullDistance, metric);
-    if (score < minSimilarity) continue;
-    const docId = state.store.docIdForOrdinal(cand.ord);
-    if (docId === void 0) continue;
-    reranked.push({
-      docId,
-      score,
-      termFrequencies: {},
-      fieldLengths: {},
-      idf: {}
-    });
-    if (reranked.length >= rerankLimit) break;
-  }
-  reranked.sort((a, b) => b.score - a.score || a.docId.localeCompare(b.docId));
-  return reranked.slice(0, k);
-}
-
 // src/vector/hnsw/index.ts
 function createHNSWIndex(dimension, store, config, quantizer) {
   const M = config?.m ?? 16;
@@ -1001,7 +1451,7 @@ function createHNSWIndex(dimension, store, config, quantizer) {
     efCons,
     buildMetric,
     mL,
-    nodesByOrd: [],
+    adjacency: createAdjacency(M, Mmax0),
     tombstones: new Uint8Array(0),
     tombstoneCount: 0,
     nodeCount: 0,
@@ -1012,7 +1462,7 @@ function createHNSWIndex(dimension, store, config, quantizer) {
     topLayer: -1
   };
   function clear() {
-    state.nodesByOrd = [];
+    resetAdjacency(state.adjacency);
     state.tombstones = new Uint8Array(0);
     state.tombstoneCount = 0;
     state.nodeCount = 0;
@@ -1023,8 +1473,8 @@ function createHNSWIndex(dimension, store, config, quantizer) {
     state.topLayer = -1;
   }
   function* entriesIterator() {
-    for (let ord = 0; ord < state.nodesByOrd.length; ord++) {
-      if (state.nodesByOrd[ord] === void 0) continue;
+    for (let ord = 0; ord < state.adjacency.slots; ord++) {
+      if (!hasNode(state.adjacency, ord)) continue;
       if (state.tombstones[ord] === 1) continue;
       const docId = state.store.docIdForOrdinal(ord);
       if (docId === void 0) continue;
@@ -1062,25 +1512,52 @@ function createHNSWIndex(dimension, store, config, quantizer) {
     get metric() {
       return state.buildMetric;
     },
+    get adjacencyBytes() {
+      return estimateAdjacencyBytes(state.adjacency);
+    },
     insertNode: (docId) => insertNode(state, docId),
     markTombstone: (docId) => markTombstone(state, docId),
     has: (docId) => {
       const ord = state.store.getOrdinal(docId);
-      return ord !== void 0 && state.nodesByOrd[ord] !== void 0 && state.tombstones[ord] !== 1;
+      return ord !== void 0 && hasNode(state.adjacency, ord) && state.tombstones[ord] !== 1;
     },
     isTombstoned: (docId) => {
       const ord = state.store.getOrdinal(docId);
       return ord !== void 0 && state.tombstones[ord] === 1;
     },
-    search: (query, k, searchMetric, minSimilarity, filterDocIds, efSearch) => search(state, query, k, searchMetric, minSimilarity, filterDocIds, efSearch),
+    search: (query, k, searchMetric, minSimilarity, filter, efSearch) => search(state, query, k, searchMetric, minSimilarity, filter, efSearch),
     clear,
     entries: entriesIterator,
     compactionNeeded,
     compactTombstones: () => compactTombstones(state),
     rebuild: () => rebuild(state),
     serialize: () => serializeGraph(state),
-    deserialize: (data) => deserializeGraph(state, data)
+    deserialize: (data) => deserializeGraph(state, data),
+    exportSnapshot: () => ({
+      dimension: state.dimension,
+      m: state.M,
+      efConstruction: state.efCons,
+      metric: state.buildMetric,
+      adjacency: exportAdjacency(state.adjacency),
+      tombstones: state.tombstones.slice(),
+      tombstoneCount: state.tombstoneCount,
+      nodeCount: state.nodeCount,
+      capacity: state.capacity,
+      entryPointOrd: state.entryPointOrd,
+      topLayer: state.topLayer
+    }),
+    restoreSnapshot: (snapshot) => {
+      state.adjacency = importAdjacency(snapshot.adjacency);
+      state.tombstones = snapshot.tombstones;
+      state.tombstoneCount = snapshot.tombstoneCount;
+      state.nodeCount = snapshot.nodeCount;
+      state.capacity = Math.max(snapshot.capacity, snapshot.adjacency.capacity);
+      state.visited = new Uint32Array(state.capacity);
+      state.visitStamp = 0;
+      state.entryPointOrd = snapshot.entryPointOrd;
+      state.topLayer = snapshot.topLayer;
+    }
   };
 }
 
-export { cosineSimilarityWithMagnitudes, createArenaSimd, createBoundedMaxHeap, createHNSWIndex, createVectorStore, dotProduct, euclideanDistance, isSimdAvailable, magnitude };
+export { ABSENT_DOCUMENT_RANK, MAX_M, addToOrdinalFilter, arenaFloat32Distance, cosineSimilarityWithMagnitudes, createArenaSimd, createBoundedMaxHeap, createHNSWIndex, createOrdinalFilter, createSharedArenaSimd, createVectorStore, dotProduct, euclideanDistance, importAdjacency, isSimdAvailable, magnitude, ordinalFilterHas, ordinalFilterValues, removeFromOrdinalFilter, searchOrdinals, toScore };