@delali/narsil 0.2.4-next.51 → 0.2.4-next.52

package/dist/chunk-X6YZO4MQ.mjs

@@ -1,1572 +0,0 @@
-import { INITIAL_LIST_CAPACITY, COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, MAX_LAYER_CAP, SQ8_OVERSELECTION_FACTOR, SQ8_RERANK_FLOOR, INITIAL_UPPER_SLOTS } from './chunk-RP23PWMV.mjs';
-import { compareCodePoints } from './chunk-2GWVQWGA.mjs';
-
-// src/vector/constants.ts
-var WASM_PAGE_BYTES = 65536;
-var MAX_WASM_PAGES = 65536;
-var VECTOR_STORE_INITIAL_CAPACITY = 16;
-var MAX_WORKER_DIMENSION = 8192;
-var MAX_WORKER_VECTORS = 1e6;
-var MAX_WORKER_COPIES = 64;
-var HNSW_BUILD_TIMEOUT_MS = 12e4;
-var VECTOR_SEARCH_TIMEOUT_MS = 3e4;
-var VECTOR_SEARCH_LOAD_TIMEOUT_MS = 3e5;
-var QUANTIZATION_PADDING_FACTOR = 0.01;
-
-// 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;
-var f32View = null;
-function decodeBase64(base64) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(base64, "base64"));
-  }
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-try {
-  const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
-  const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-  if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
-    const module = new WebAssembly.Module(wasmBuffer);
-    const instance = new WebAssembly.Instance(module);
-    wasmExports = instance.exports;
-    f32View = new Float32Array(wasmExports.memory.buffer);
-  }
-} catch {
-  wasmExports = null;
-  f32View = null;
-}
-var OFFSET_B_BYTES = 16384;
-function ensureMemory(dim) {
-  if (!wasmExports || !f32View) return;
-  const needed = OFFSET_B_BYTES + dim * 4;
-  const currentSize = wasmExports.memory.buffer.byteLength;
-  if (needed > currentSize) {
-    const pagesNeeded = Math.ceil(needed / 65536);
-    const currentPages = currentSize / 65536;
-    wasmExports.memory.grow(pagesNeeded - currentPages);
-    f32View = new Float32Array(wasmExports.memory.buffer);
-  }
-}
-function getF32View() {
-  if (!f32View) {
-    throw new Error("SIMD memory is not initialized");
-  }
-  return f32View;
-}
-function copyOneVector(a) {
-  getF32View().set(a, 0);
-}
-function copyTwoVectors(a, b) {
-  const view = getF32View();
-  view.set(a, 0);
-  view.set(b, OFFSET_B_BYTES / 4);
-}
-function simdDotProduct(a, b) {
-  if (!wasmExports || !f32View) return null;
-  ensureMemory(a.length);
-  copyTwoVectors(a, b);
-  return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
-}
-function simdMagnitude(a) {
-  if (!wasmExports || !f32View) return null;
-  ensureMemory(a.length);
-  copyOneVector(a);
-  return wasmExports.magnitude(0, a.length);
-}
-function simdEuclideanDistance(a, b) {
-  if (!wasmExports || !f32View) return null;
-  ensureMemory(a.length);
-  copyTwoVectors(a, b);
-  return wasmExports.euclidean_distance(0, OFFSET_B_BYTES, a.length);
-}
-function isSimdAvailable() {
-  return wasmExports !== null;
-}
-var arenaModule;
-function getArenaModule() {
-  if (arenaModule !== void 0) return arenaModule;
-  try {
-    const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
-    const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-    if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
-      arenaModule = null;
-      return null;
-    }
-    arenaModule = new WebAssembly.Module(wasmBuffer);
-  } catch {
-    arenaModule = null;
-  }
-  return arenaModule;
-}
-function createArenaSimd() {
-  try {
-    const module = getArenaModule();
-    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" || 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;
-  } catch {
-    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) {
-  const result = simdMagnitude(v);
-  if (result !== null) return result;
-  let sum = 0;
-  for (let i = 0; i < v.length; i++) {
-    sum += v[i] * v[i];
-  }
-  return Math.sqrt(sum);
-}
-function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
-  if (magA === 0 || magB === 0) return 0;
-  return dotProduct(a, b) / (magA * magB);
-}
-function dotProduct(a, b) {
-  const result = simdDotProduct(a, b);
-  if (result !== null) return result;
-  let sum = 0;
-  for (let i = 0; i < a.length; i++) {
-    sum += a[i] * b[i];
-  }
-  return sum;
-}
-function euclideanDistance(a, b) {
-  const result = simdEuclideanDistance(a, b);
-  if (result !== null) return result;
-  let sum = 0;
-  for (let i = 0; i < a.length; i++) {
-    const diff = a[i] - b[i];
-    sum += diff * diff;
-  }
-  return Math.sqrt(sum);
-}
-
-// src/vector/vector-store/index.ts
-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);
-    }
-  }
-  function ensureCapacity2(needed) {
-    if (needed <= capacity) return;
-    let newCap = capacity === 0 ? VECTOR_STORE_INITIAL_CAPACITY : capacity;
-    while (newCap < needed) newCap *= 2;
-    const nextMags = new Float64Array(newCap);
-    nextMags.set(mags);
-    mags = nextMags;
-    if (simd) {
-      const requiredBytes = scratchByteLength + newCap * dimension * 4;
-      const have = simd.memory.buffer.byteLength;
-      if (requiredBytes > have) {
-        try {
-          simd.memory.grow(Math.ceil((requiredBytes - have) / WASM_PAGE_BYTES));
-        } catch {
-          const migrated = new Float32Array(newCap * dimension);
-          migrated.set(arena.subarray(scratchFloatLength, scratchFloatLength + capacity * dimension));
-          arena = migrated;
-          simd = null;
-          scratchByteLength = 0;
-          scratchFloatLength = 0;
-          capacity = newCap;
-          return;
-        }
-      }
-      arena = new Float32Array(simd.memory.buffer);
-    } else {
-      const nextArena = new Float32Array(newCap * dimension);
-      nextArena.set(arena.subarray(0, capacity * dimension));
-      arena = nextArena;
-    }
-    capacity = newCap;
-  }
-  function writeVector(ord, vector) {
-    arena.set(vector, scratchFloatLength + ord * dimension);
-    mags[ord] = magnitude(vector);
-  }
-  function entryAt(ord) {
-    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 ? VECTOR_STORE_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;
-    },
-    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);
-      if (recycled !== void 0) {
-        recycledOrds.delete(docId);
-        docToOrd.set(docId, recycled);
-        ordToDoc[recycled] = docId;
-        ensureCapacity2(recycled + 1);
-        writeVector(recycled, vector);
-        recordPartition(recycled, partitionId, false);
-        liveCount++;
-        return;
-      }
-      const ord = ordToDoc.length;
-      docToOrd.set(docId, ord);
-      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) {
-      const ord = docToOrd.get(docId);
-      return ord === void 0 ? void 0 : entryAt(ord);
-    },
-    has(docId) {
-      return docToOrd.has(docId);
-    },
-    *entries() {
-      for (let ord = 0; ord < ordToDoc.length; ord++) {
-        const docId = ordToDoc[ord];
-        if (docId === void 0) continue;
-        yield [docId, entryAt(ord)];
-      }
-    },
-    clear() {
-      docToOrd.clear();
-      recycledOrds.clear();
-      ordToDoc.length = 0;
-      partitionOf = new Int32Array(0);
-      unknownPartitions = 0;
-      mags = new Float64Array(0);
-      if (!simd) {
-        arena = new Float32Array(0);
-      }
-      dimension = 0;
-      capacity = 0;
-      liveCount = 0;
-      scratchByteLength = 0;
-      scratchFloatLength = 0;
-    },
-    getOrdinal(docId) {
-      return docToOrd.get(docId);
-    },
-    docIdForOrdinal(ordinal) {
-      return ordToDoc[ordinal];
-    },
-    entryForOrdinal(ordinal) {
-      if (ordinal < 0 || ordinal >= ordToDoc.length || ordToDoc[ordinal] === void 0) return void 0;
-      return entryAt(ordinal);
-    },
-    distanceByOrdinal(ordA, ordB, metric) {
-      if (ordToDoc[ordA] === void 0 || ordToDoc[ordB] === void 0) return Number.POSITIVE_INFINITY;
-      if (simd) {
-        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 = scratchFloatLength + ordA * dimension;
-      const baseB = scratchFloatLength + ordB * dimension;
-      const a = arena.subarray(baseA, baseA + dimension);
-      const b = arena.subarray(baseB, baseB + dimension);
-      switch (metric) {
-        case "cosine":
-          return 1 - cosineSimilarityWithMagnitudes(a, b, mags[ordA], mags[ordB]);
-        case "dotProduct":
-          return -dotProduct(a, b);
-        case "euclidean":
-          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;
-      const MAP_OVERHEAD = 64;
-      const MAP_ENTRY = 72;
-      const AVG_DOCID_BYTES = 56;
-      const MAGNITUDE_BYTES = 8;
-      const ORDINAL_SLOT = 16;
-      const perEntry = MAP_ENTRY + AVG_DOCID_BYTES + MAGNITUDE_BYTES + ORDINAL_SLOT;
-      return MAP_OVERHEAD + count * (perEntry + dimension2 * 4);
-    }
-  };
-}
-
-// src/vector/hnsw/adjacency.ts
-var ABSENT = -1;
-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, count) {
-  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(count, 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
-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;
-  const nextTombstones = new Uint8Array(newCap);
-  nextTombstones.set(state.tombstones);
-  state.tombstones = nextTombstones;
-  state.visited = new Uint32Array(newCap);
-  state.visitStamp = 0;
-  state.capacity = newCap;
-}
-function nextVisitStamp(state) {
-  state.visitStamp++;
-  if (state.visitStamp === 4294967295) {
-    state.visited.fill(0);
-    state.visitStamp = 1;
-  }
-  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":
-      return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
-    case "dotProduct":
-      return -dotProduct(a, b);
-    case "euclidean":
-      return euclideanDistance(a, b);
-  }
-}
-function toScore(distance, metric) {
-  switch (metric) {
-    case "cosine":
-      return 1 - distance;
-    case "dotProduct":
-      return -distance;
-    case "euclidean":
-      return 1 / (1 + distance);
-  }
-}
-function randomLevel(mL) {
-  let u = Math.random();
-  if (u === 0) u = Number.MIN_VALUE;
-  return Math.min(Math.floor(-Math.log(u) * mL), MAX_LAYER_CAP);
-}
-function entryForOrd(state, ord) {
-  return state.store.entryForOrdinal(ord);
-}
-function nodeDistanceByOrd(state, aOrd, bOrd, metric) {
-  return state.store.distanceByOrdinal(aOrd, bOrd, metric);
-}
-function queryDistanceByOrd(state, qVec, qMag, ord, metric) {
-  const entry = state.store.entryForOrdinal(ord);
-  if (!entry) return Number.POSITIVE_INFINITY;
-  return toDistance(qVec, entry.vector, qMag, entry.magnitude, metric);
-}
-function maxConns(state, layer) {
-  return layer === 0 ? state.Mmax0 : state.M;
-}
-function addConnection(connections, ord) {
-  for (let i = 0; i < connections.length; i++) {
-    if (connections[i] === ord) return;
-  }
-  connections.push(ord);
-}
-
-// src/vector/hnsw/workspace.ts
-function createList(capacity) {
-  return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
-}
-function createHeap(greatestFirst) {
-  return { ...createList(INITIAL_LIST_CAPACITY), greatestFirst, topOrd: -1, topDistance: 0 };
-}
-function createHNSWWorkspace() {
-  return {
-    frontier: createHeap(false),
-    found: createHeap(true),
-    entryPoints: new Int32Array(INITIAL_LIST_CAPACITY),
-    entryPointCount: 0,
-    traversal: createList(INITIAL_LIST_CAPACITY),
-    working: createList(INITIAL_LIST_CAPACITY),
-    insertSelection: createList(INITIAL_LIST_CAPACITY),
-    pruneCandidates: createList(INITIAL_LIST_CAPACITY),
-    pruneSelection: createList(INITIAL_LIST_CAPACITY),
-    repairCandidates: createList(INITIAL_LIST_CAPACITY),
-    repairSelection: createList(INITIAL_LIST_CAPACITY)
-  };
-}
-function ensureListCapacity(list, needed) {
-  if (needed <= list.ords.length) return;
-  let capacity = list.ords.length === 0 ? INITIAL_LIST_CAPACITY : list.ords.length;
-  while (capacity < needed) capacity *= 2;
-  const ords = new Int32Array(capacity);
-  ords.set(list.ords);
-  list.ords = ords;
-  const distances = new Float64Array(capacity);
-  distances.set(list.distances);
-  list.distances = distances;
-}
-function appendToList(list, ord, distance) {
-  ensureListCapacity(list, list.size + 1);
-  list.ords[list.size] = ord;
-  list.distances[list.size] = distance;
-  list.size += 1;
-}
-function copyList(source, target) {
-  ensureListCapacity(target, source.size);
-  target.ords.set(source.ords.subarray(0, source.size));
-  target.distances.set(source.distances.subarray(0, source.size));
-  target.size = source.size;
-}
-function sortListByDistance(list) {
-  const { ords, distances } = list;
-  for (let i = 1; i < list.size; i++) {
-    const ord = ords[i];
-    const distance = distances[i];
-    let j = i - 1;
-    while (j >= 0 && distances[j] > distance) {
-      distances[j + 1] = distances[j];
-      ords[j + 1] = ords[j];
-      j -= 1;
-    }
-    distances[j + 1] = distance;
-    ords[j + 1] = ord;
-  }
-}
-function heapPrecedes(heap, a, b) {
-  return heap.greatestFirst ? heap.distances[a] > heap.distances[b] : heap.distances[a] < heap.distances[b];
-}
-function swapHeapEntries(heap, a, b) {
-  const ord = heap.ords[a];
-  heap.ords[a] = heap.ords[b];
-  heap.ords[b] = ord;
-  const distance = heap.distances[a];
-  heap.distances[a] = heap.distances[b];
-  heap.distances[b] = distance;
-}
-function pushHeap(heap, ord, distance) {
-  appendToList(heap, ord, distance);
-  let index = heap.size - 1;
-  while (index > 0) {
-    const parent = index - 1 >> 1;
-    if (!heapPrecedes(heap, index, parent)) break;
-    swapHeapEntries(heap, index, parent);
-    index = parent;
-  }
-}
-function popHeap(heap) {
-  if (heap.size === 0) return false;
-  heap.topOrd = heap.ords[0];
-  heap.topDistance = heap.distances[0];
-  heap.size -= 1;
-  if (heap.size > 0) {
-    heap.ords[0] = heap.ords[heap.size];
-    heap.distances[0] = heap.distances[heap.size];
-    let index = 0;
-    for (; ; ) {
-      const left = 2 * index + 1;
-      const right = left + 1;
-      let first = index;
-      if (left < heap.size && heapPrecedes(heap, left, first)) first = left;
-      if (right < heap.size && heapPrecedes(heap, right, first)) first = right;
-      if (first === index) break;
-      swapHeapEntries(heap, index, first);
-      index = first;
-    }
-  }
-  return true;
-}
-function resetHeap(heap) {
-  heap.size = 0;
-}
-function drainHeapNearestFirst(heap, list) {
-  const count = heap.size;
-  ensureListCapacity(list, count);
-  list.size = count;
-  for (let i = count - 1; i >= 0; i--) {
-    if (!popHeap(heap)) break;
-    list.ords[i] = heap.topOrd;
-    list.distances[i] = heap.topDistance;
-  }
-}
-function setSingleEntryPoint(workspace, ord) {
-  workspace.entryPoints[0] = ord;
-  workspace.entryPointCount = 1;
-}
-function setEntryPointsFromList(workspace, list) {
-  if (list.size > workspace.entryPoints.length) {
-    let capacity = workspace.entryPoints.length;
-    while (capacity < list.size) capacity *= 2;
-    workspace.entryPoints = new Int32Array(capacity);
-  }
-  workspace.entryPoints.set(list.ords.subarray(0, list.size));
-  workspace.entryPointCount = list.size;
-}
-
-// src/vector/hnsw/graph-ops.ts
-function searchLayer(state, qVec, qMag, ef, layer, metric, skipTombstones, distFn, results) {
-  const getDistance = distFn ?? ((ord) => queryDistanceByOrd(state, qVec, qMag, ord, metric));
-  const workspace = state.workspace;
-  const frontier = workspace.frontier;
-  const found = workspace.found;
-  const adjacency = state.adjacency;
-  const neighbors = layerArray(adjacency, layer);
-  const visited = state.visited;
-  const stamp = nextVisitStamp(state);
-  resetHeap(frontier);
-  resetHeap(found);
-  let furthestDist = Number.POSITIVE_INFINITY;
-  for (let i = 0; i < workspace.entryPointCount; i++) {
-    const epOrd = workspace.entryPoints[i];
-    if (visited[epOrd] === stamp) continue;
-    visited[epOrd] = stamp;
-    if (!nodeExists(state, epOrd)) continue;
-    if (skipTombstones && state.tombstones[epOrd] === 1) continue;
-    const dist = getDistance(epOrd);
-    if (dist === Number.POSITIVE_INFINITY) continue;
-    pushHeap(frontier, epOrd, dist);
-    pushHeap(found, epOrd, dist);
-    if (found.size > ef) {
-      popHeap(found);
-    }
-  }
-  if (found.size > 0) furthestDist = found.distances[0];
-  while (popHeap(frontier)) {
-    if (frontier.topDistance > furthestDist) break;
-    const base = layerBase(adjacency, frontier.topOrd, 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;
-      if (!nodeExists(state, neighborOrd)) continue;
-      const dist = getDistance(neighborOrd);
-      if (dist === Number.POSITIVE_INFINITY) continue;
-      if (dist < furthestDist || found.size < ef) {
-        pushHeap(frontier, neighborOrd, dist);
-        pushHeap(found, neighborOrd, dist);
-        if (found.size > ef) {
-          popHeap(found);
-        }
-        furthestDist = found.distances[0];
-      }
-    }
-  }
-  drainHeapNearestFirst(found, results);
-}
-function selectNeighborsHeuristic(state, candidates, maxConnections, metric, selected) {
-  const working = state.workspace.working;
-  copyList(candidates, working);
-  sortListByDistance(working);
-  ensureListCapacity(selected, Math.min(maxConnections, working.size));
-  selected.size = 0;
-  for (let i = 0; i < working.size; i++) {
-    if (selected.size >= maxConnections) break;
-    const candidateOrd = working.ords[i];
-    const candidateDistance = working.distances[i];
-    let accepted = true;
-    for (let s = 0; s < selected.size; s++) {
-      const distBetween = nodeDistanceByOrd(state, candidateOrd, selected.ords[s], metric);
-      if (candidateDistance >= distBetween) {
-        accepted = false;
-        break;
-      }
-    }
-    if (!accepted) continue;
-    selected.ords[selected.size] = candidateOrd;
-    selected.distances[selected.size] = candidateDistance;
-    selected.size += 1;
-  }
-}
-function pruneConnections(state, ord, layer, metric) {
-  const adjacency = state.adjacency;
-  const base = layerBase(adjacency, ord, layer);
-  if (base === -1) return;
-  const mc = maxConns(state, layer);
-  const neighbors = layerArray(adjacency, layer);
-  const count = neighbors[base];
-  if (count <= mc) return;
-  const candidates = state.workspace.pruneCandidates;
-  candidates.size = 0;
-  ensureListCapacity(candidates, count);
-  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;
-    candidates.ords[candidates.size] = connOrd;
-    candidates.distances[candidates.size] = dist;
-    candidates.size += 1;
-  }
-  const kept = state.workspace.pruneSelection;
-  selectNeighborsHeuristic(state, candidates, mc, metric, kept);
-  replaceNeighbors(adjacency, ord, layer, kept.ords, kept.size);
-}
-
-// 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);
-  }
-  const workspace = state.workspace;
-  const candidates = workspace.traversal;
-  setSingleEntryPoint(workspace, state.entryPointOrd);
-  for (let layer = state.topLayer; layer >= 1; layer--) {
-    searchLayer(state, query, qMag, 1, layer, searchMetric, true, distFn, candidates);
-    if (candidates.size > 0) {
-      setSingleEntryPoint(workspace, candidates.ords[0]);
-    }
-  }
-  searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates);
-  if (useQuantized) {
-    return rerankWithFullPrecision(
-      state,
-      candidates,
-      query,
-      qMag,
-      arenaQuery,
-      k,
-      searchMetric,
-      minSimilarity,
-      filter,
-      hasDocument
-    );
-  }
-  const hits = [];
-  for (let i = 0; i < candidates.size; i++) {
-    const ord = candidates.ords[i];
-    if (filter && !ordinalFilterHas(filter, ord)) continue;
-    const score = toScore(candidates.distances[i], searchMetric);
-    if (score < minSimilarity) continue;
-    if (!hasDocument(ord)) continue;
-    hits.push({ 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, SQ8_RERANK_FLOOR);
-  for (let i = 0; i < candidates.size; i++) {
-    const ord = candidates.ords[i];
-    if (filter && !ordinalFilterHas(filter, ord)) continue;
-    let fullDistance;
-    if (arenaQuery) {
-      fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
-      if (fullDistance === Number.POSITIVE_INFINITY) continue;
-    } else {
-      const entry = entryForOrd(state, ord);
-      if (!entry) continue;
-      fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
-    }
-    const score = toScore(fullDistance, metric);
-    if (score < minSimilarity) continue;
-    if (!hasDocument(ord)) continue;
-    reranked.push({ 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;
-    state.tombstoneCount--;
-  }
-}
-function highestNode(state, includeTombstoned) {
-  let bestOrd = -1;
-  let bestLayer = -1;
-  for (let ord = 0; ord < state.adjacency.slots; ord++) {
-    const level = nodeMaxLayer(state, ord);
-    if (level === -1) continue;
-    if (!includeTombstoned && state.tombstones[ord] === 1) continue;
-    if (level > bestLayer) {
-      bestLayer = level;
-      bestOrd = ord;
-    }
-  }
-  return bestOrd;
-}
-function setEntryPoint(state, ord) {
-  state.entryPointOrd = ord;
-  state.topLayer = ord === -1 ? -1 : nodeMaxLayer(state, ord);
-}
-function insertNode(state, docId) {
-  const ord = state.store.getOrdinal(docId);
-  if (ord === void 0) {
-    throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
-  }
-  const entry = state.store.entryForOrdinal(ord);
-  if (!entry) {
-    throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
-  }
-  if (entry.vector.length !== state.dimension) {
-    throw new Error(`Vector dimension mismatch: expected ${state.dimension}, got ${entry.vector.length}`);
-  }
-  ensureCapacity(state, ord + 1);
-  if (nodeExists(state, ord)) {
-    removeNodeEager(state, ord);
-  }
-  clearTombstone(state, ord);
-  const l = randomLevel(state.mL);
-  createNode(state.adjacency, ord, l);
-  state.nodeCount++;
-  if (state.entryPointOrd === -1) {
-    state.entryPointOrd = ord;
-    state.topLayer = l;
-    return;
-  }
-  const metric = state.buildMetric;
-  const workspace = state.workspace;
-  const candidates = workspace.traversal;
-  const selected = workspace.insertSelection;
-  const insertDistFn = (candOrd) => nodeDistanceByOrd(state, ord, candOrd, metric);
-  setSingleEntryPoint(workspace, state.entryPointOrd);
-  for (let layer = state.topLayer; layer > l; layer--) {
-    searchLayer(state, entry.vector, entry.magnitude, 1, layer, metric, false, insertDistFn, candidates);
-    if (candidates.size > 0) {
-      setSingleEntryPoint(workspace, candidates.ords[0]);
-    }
-  }
-  for (let layer = Math.min(l, state.topLayer); layer >= 0; layer--) {
-    searchLayer(state, entry.vector, entry.magnitude, state.efCons, layer, metric, false, insertDistFn, candidates);
-    selectNeighborsHeuristic(state, candidates, maxConns(state, layer), metric, selected);
-    for (let i = 0; i < selected.size; i++) {
-      const neighborOrd = selected.ords[i];
-      addNeighbor(state.adjacency, ord, layer, neighborOrd);
-      if (layer <= nodeMaxLayer(state, neighborOrd)) {
-        addNeighbor(state.adjacency, neighborOrd, layer, ord);
-        pruneConnections(state, neighborOrd, layer, metric);
-      }
-    }
-    if (candidates.size > 0) {
-      setEntryPointsFromList(workspace, candidates);
-    }
-  }
-  if (l > state.topLayer) {
-    state.entryPointOrd = ord;
-    state.topLayer = l;
-  }
-}
-function removeNodeEager(state, ord, excludeOrds) {
-  const maxLayer = nodeMaxLayer(state, ord);
-  if (maxLayer === -1) return;
-  const metric = state.buildMetric;
-  for (let layer = 0; layer <= maxLayer; layer++) {
-    const formerNeighbors = collectNeighbors(state.adjacency, ord, layer);
-    for (const neighborOrd of formerNeighbors) {
-      if (layer <= nodeMaxLayer(state, neighborOrd)) {
-        removeNeighbor(state.adjacency, neighborOrd, layer, ord);
-      }
-    }
-    for (const neighborOrd of formerNeighbors) {
-      if (layer > nodeMaxLayer(state, neighborOrd)) continue;
-      const mc = maxConns(state, 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;
-          candidateOrds.add(otherOrd);
-        }
-      }
-      const candidates = state.workspace.repairCandidates;
-      candidates.size = 0;
-      for (const candOrd of candidateOrds) {
-        const dist = nodeDistanceByOrd(state, neighborOrd, candOrd, metric);
-        if (dist === Number.POSITIVE_INFINITY) continue;
-        appendToList(candidates, candOrd, dist);
-      }
-      const selected = state.workspace.repairSelection;
-      selectNeighborsHeuristic(state, candidates, mc, metric, selected);
-      replaceNeighbors(state.adjacency, neighborOrd, layer, selected.ords, selected.size);
-      for (let i = 0; i < selected.size; i++) {
-        const newConnOrd = selected.ords[i];
-        if (layer <= nodeMaxLayer(state, newConnOrd)) {
-          addNeighbor(state.adjacency, newConnOrd, layer, neighborOrd);
-          pruneConnections(state, newConnOrd, layer, metric);
-        }
-      }
-    }
-  }
-  deleteNode(state.adjacency, ord);
-  state.nodeCount--;
-  clearTombstone(state, ord);
-  if (state.entryPointOrd === ord) {
-    if (state.nodeCount === 0) {
-      setEntryPoint(state, -1);
-      return;
-    }
-    const live = highestNode(state, false);
-    setEntryPoint(state, live === -1 ? highestNode(state, true) : live);
-  }
-}
-function markTombstone(state, docId) {
-  const ord = state.store.getOrdinal(docId);
-  if (ord === void 0 || !nodeExists(state, ord)) return;
-  if (state.tombstones[ord] === 0) {
-    state.tombstones[ord] = 1;
-    state.tombstoneCount++;
-  }
-  if (state.entryPointOrd === ord) {
-    setEntryPoint(state, highestNode(state, false));
-  }
-}
-function compactTombstones(state) {
-  if (state.tombstoneCount === 0) return;
-  const tombstonedOrds = [];
-  for (let ord = 0; ord < state.adjacency.slots; ord++) {
-    if (state.tombstones[ord] === 1 && nodeExists(state, ord)) {
-      tombstonedOrds.push(ord);
-    }
-  }
-  const excl = new Set(tombstonedOrds);
-  for (const ord of tombstonedOrds) {
-    removeNodeEager(state, ord, excl);
-  }
-}
-function rebuild(state) {
-  if (state.tombstoneCount === 0 && state.nodeCount === 0) return;
-  const liveOrds = [];
-  for (let ord = 0; ord < state.adjacency.slots; ord++) {
-    if (nodeExists(state, ord) && state.tombstones[ord] !== 1) {
-      liveOrds.push(ord);
-    }
-  }
-  resetAdjacency(state.adjacency);
-  state.tombstones.fill(0);
-  state.tombstoneCount = 0;
-  state.nodeCount = 0;
-  state.entryPointOrd = -1;
-  state.topLayer = -1;
-  for (const ord of liveOrds) {
-    const docId = state.store.docIdForOrdinal(ord);
-    if (docId === void 0) continue;
-    if (state.store.entryForOrdinal(ord) === void 0) continue;
-    insertNode(state, docId);
-  }
-}
-
-// src/vector/hnsw/persistence.ts
-function serializeGraph(state) {
-  const nodeArray = [];
-  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 <= maxLayer; layer++) {
-      const liveNeighbors = [];
-      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;
-        liveNeighbors.push(neighborDoc);
-      }
-      if (liveNeighbors.length > 0) {
-        layerConns.push([layer, liveNeighbors]);
-      }
-    }
-    nodeArray.push([docId, maxLayer, layerConns]);
-  }
-  const entryPoint = state.entryPointOrd === -1 ? null : state.store.docIdForOrdinal(state.entryPointOrd) ?? null;
-  return {
-    entryPoint,
-    maxLayer: state.topLayer,
-    m: state.M,
-    efConstruction: state.efCons,
-    metric: state.buildMetric,
-    nodes: nodeArray
-  };
-}
-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 clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
-    const layers = [];
-    for (const [layer, neighbors] of layerConns) {
-      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]);
-    }
-    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, neighbors.length);
-    }
-    state.nodeCount++;
-  }
-  if (data.entryPoint != null && data.entryPoint !== "") {
-    const epOrd = state.store.getOrdinal(data.entryPoint);
-    if (epOrd !== void 0 && nodeExists(state, epOrd)) {
-      state.entryPointOrd = epOrd;
-      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.adjacency.slots; ord++) {
-      const level = nodeMaxLayer(state, ord);
-      if (level === -1) continue;
-      if (level > bestLayer) {
-        bestLayer = level;
-        bestOrd = ord;
-      }
-    }
-    state.entryPointOrd = bestOrd;
-    state.topLayer = bestLayer;
-  }
-}
-
-// src/vector/hnsw/index.ts
-function createHNSWIndex(dimension, store, config, quantizer) {
-  const M = config?.m ?? 16;
-  const Mmax0 = M * 2;
-  const efCons = config?.efConstruction ?? 200;
-  const buildMetric = config?.metric ?? "cosine";
-  const mL = 1 / Math.log(M);
-  const state = {
-    dimension,
-    store,
-    quantizer,
-    M,
-    Mmax0,
-    efCons,
-    buildMetric,
-    mL,
-    adjacency: createAdjacency(M, Mmax0),
-    tombstones: new Uint8Array(0),
-    tombstoneCount: 0,
-    nodeCount: 0,
-    capacity: 0,
-    visited: new Uint32Array(0),
-    visitStamp: 0,
-    entryPointOrd: -1,
-    topLayer: -1,
-    workspace: createHNSWWorkspace()
-  };
-  function clear() {
-    resetAdjacency(state.adjacency);
-    state.tombstones = new Uint8Array(0);
-    state.tombstoneCount = 0;
-    state.nodeCount = 0;
-    state.capacity = 0;
-    state.visited = new Uint32Array(0);
-    state.visitStamp = 0;
-    state.entryPointOrd = -1;
-    state.topLayer = -1;
-  }
-  function* entriesIterator() {
-    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;
-      const entry = state.store.entryForOrdinal(ord);
-      if (!entry) continue;
-      yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
-    }
-  }
-  function compactionNeeded() {
-    if (state.nodeCount === 0) return false;
-    return state.tombstoneCount / state.nodeCount > COMPACTION_TOMBSTONE_RATIO || state.tombstoneCount > COMPACTION_ABSOLUTE_THRESHOLD;
-  }
-  return {
-    get dimension() {
-      return state.dimension;
-    },
-    get size() {
-      return state.nodeCount - state.tombstoneCount;
-    },
-    get tombstoneCount() {
-      return state.tombstoneCount;
-    },
-    get entryPointId() {
-      return state.entryPointOrd === -1 ? null : state.store.docIdForOrdinal(state.entryPointOrd) ?? null;
-    },
-    get topLayer() {
-      return state.topLayer;
-    },
-    get m() {
-      return state.M;
-    },
-    get efConstruction() {
-      return state.efCons;
-    },
-    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 && 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, 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),
-    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 { ABSENT_DOCUMENT_RANK, HNSW_BUILD_TIMEOUT_MS, MAX_WASM_PAGES, MAX_WORKER_COPIES, MAX_WORKER_DIMENSION, MAX_WORKER_VECTORS, QUANTIZATION_PADDING_FACTOR, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_STORE_INITIAL_CAPACITY, WASM_PAGE_BYTES, addToOrdinalFilter, arenaFloat32Distance, cosineSimilarityWithMagnitudes, createArenaSimd, createHNSWIndex, createHNSWWorkspace, createOrdinalFilter, createSharedArenaSimd, createVectorStore, dotProduct, entryForOrd, euclideanDistance, importAdjacency, isSimdAvailable, magnitude, ordinalFilterHas, ordinalFilterValues, removeFromOrdinalFilter, searchOrdinals, toDistance, toScore };