@delali/narsil 0.1.7 → 0.1.9

package/dist/chunk-S7RJJMHI.mjs

@@ -0,0 +1,1086 @@
+// 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=";
+
+// 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" || !(exports$1.memory instanceof WebAssembly.Memory)) {
+      return null;
+    }
+    return exports$1;
+  } catch {
+    return null;
+  }
+}
+
+// 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.ts
+var INITIAL_CAPACITY = 16;
+var PAGE_BYTES = 65536;
+function createVectorStore() {
+  const docToOrd = /* @__PURE__ */ new Map();
+  const recycledOrds = /* @__PURE__ */ new Map();
+  const ordToDoc = [];
+  let simd = createArenaSimd();
+  let dimension = 0;
+  let capacity = 0;
+  let arena = new Float32Array(0);
+  let mags = new Float64Array(0);
+  let liveCount = 0;
+  function initStorage(dim) {
+    dimension = dim;
+    if (simd) {
+      arena = new Float32Array(simd.memory.buffer);
+    }
+  }
+  function ensureCapacity2(needed) {
+    if (needed <= capacity) return;
+    let newCap = capacity === 0 ? INITIAL_CAPACITY : capacity;
+    while (newCap < needed) newCap *= 2;
+    const nextMags = new Float64Array(newCap);
+    nextMags.set(mags);
+    mags = nextMags;
+    if (simd) {
+      const requiredBytes = 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));
+          arena = migrated;
+          simd = null;
+          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, ord * dimension);
+    mags[ord] = magnitude(vector);
+  }
+  function entryAt(ord) {
+    const base = ord * dimension;
+    return { vector: arena.subarray(base, base + dimension), magnitude: mags[ord] };
+  }
+  return {
+    get size() {
+      return liveCount;
+    },
+    insert(docId, vector) {
+      if (dimension === 0) initStorage(vector.length);
+      const existing = docToOrd.get(docId);
+      if (existing !== void 0) {
+        writeVector(existing, vector);
+        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);
+        liveCount++;
+        return;
+      }
+      const ord = ordToDoc.length;
+      docToOrd.set(docId, ord);
+      ordToDoc.push(docId);
+      ensureCapacity2(ord + 1);
+      writeVector(ord, vector);
+      liveCount++;
+    },
+    remove(docId) {
+      const ord = docToOrd.get(docId);
+      if (ord === void 0) return;
+      docToOrd.delete(docId);
+      ordToDoc[ord] = void 0;
+      recycledOrds.set(docId, ord);
+      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;
+      mags = new Float64Array(0);
+      if (!simd) {
+        arena = new Float32Array(0);
+      }
+      dimension = 0;
+      capacity = 0;
+      liveCount = 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 = 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 baseA = ordA * dimension;
+      const baseB = 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);
+      }
+    },
+    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/core/heap.ts
+function createMinHeap(compare) {
+  return createHeap(compare);
+}
+function createMaxHeap(compare) {
+  return createHeap((a, b) => compare(b, a));
+}
+function createBoundedMaxHeap(compare, capacity) {
+  const heap = createMaxHeap(compare);
+  const innerPush = heap.push;
+  return {
+    push(item) {
+      if (heap.size < capacity) {
+        innerPush(item);
+        return;
+      }
+      const top = heap.peek();
+      if (top !== void 0 && compare(item, top) < 0) {
+        heap.pop();
+        innerPush(item);
+      }
+    },
+    pop: heap.pop,
+    peek: heap.peek,
+    get size() {
+      return heap.size;
+    },
+    toSortedArray: heap.toSortedArray
+  };
+}
+function createHeap(compare) {
+  const items = [];
+  function siftUp(idx) {
+    while (idx > 0) {
+      const parent = idx - 1 >> 1;
+      if (compare(items[idx], items[parent]) >= 0) break;
+      const tmp = items[idx];
+      items[idx] = items[parent];
+      items[parent] = tmp;
+      idx = parent;
+    }
+  }
+  function siftDown(idx) {
+    const len = items.length;
+    while (true) {
+      let smallest = idx;
+      const left = 2 * idx + 1;
+      const right = 2 * idx + 2;
+      if (left < len && compare(items[left], items[smallest]) < 0) smallest = left;
+      if (right < len && compare(items[right], items[smallest]) < 0) smallest = right;
+      if (smallest === idx) break;
+      const tmp = items[idx];
+      items[idx] = items[smallest];
+      items[smallest] = tmp;
+      idx = smallest;
+    }
+  }
+  return {
+    push(item) {
+      items.push(item);
+      siftUp(items.length - 1);
+    },
+    pop() {
+      if (items.length === 0) return void 0;
+      const top = items[0];
+      const last = items.pop();
+      if (items.length > 0) {
+        items[0] = last;
+        siftDown(0);
+      }
+      return top;
+    },
+    peek() {
+      return items[0];
+    },
+    get size() {
+      return items.length;
+    },
+    toSortedArray() {
+      return [...items].sort(compare);
+    }
+  };
+}
+
+// src/vector/hnsw/shared.ts
+var MAX_LAYER_CAP = 32;
+var COMPACTION_TOMBSTONE_RATIO = 0.1;
+var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
+var SQ8_OVERSELECTION_FACTOR = 2;
+function ensureCapacity(state, 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 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);
+  }
+}
+var distanceAsc = (a, b) => a.distance - b.distance;
+var distanceDesc = (a, b) => b.distance - a.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/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 visited = state.visited;
+  const stamp = nextVisitStamp(state);
+  const candidates = createMinHeap(distanceAsc);
+  const results = createMinHeap(distanceDesc);
+  let furthestDist = Number.POSITIVE_INFINITY;
+  for (const epOrd of eps) {
+    if (visited[epOrd] === stamp) continue;
+    visited[epOrd] = stamp;
+    const node = state.nodesByOrd[epOrd];
+    if (!node) continue;
+    if (skipTombstones && state.tombstones[epOrd] === 1) continue;
+    const dist = getDistance(epOrd);
+    if (dist === Number.POSITIVE_INFINITY) continue;
+    const pair = { ord: epOrd, distance: dist };
+    candidates.push(pair);
+    results.push(pair);
+    if (results.size > ef) {
+      results.pop();
+    }
+  }
+  const topResult = results.peek();
+  if (topResult) furthestDist = topResult.distance;
+  while (candidates.size > 0) {
+    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]) {
+      if (visited[neighborOrd] === stamp) continue;
+      visited[neighborOrd] = stamp;
+      if (skipTombstones && state.tombstones[neighborOrd] === 1) continue;
+      const neighborNode = state.nodesByOrd[neighborOrd];
+      if (!neighborNode) continue;
+      const dist = getDistance(neighborOrd);
+      if (dist === Number.POSITIVE_INFINITY) continue;
+      if (dist < furthestDist || results.size < ef) {
+        const pair = { ord: neighborOrd, distance: dist };
+        candidates.push(pair);
+        results.push(pair);
+        if (results.size > ef) {
+          results.pop();
+        }
+        const newTop = results.peek();
+        if (newTop) furthestDist = newTop.distance;
+      }
+    }
+  }
+  return results;
+}
+function nearestFromHeap(heap) {
+  let nearest;
+  while (heap.size > 0) {
+    nearest = heap.pop();
+  }
+  return nearest;
+}
+function selectNeighborsHeuristic(state, targetOrd, candidates, maxConnections, layer, metric, extendCandidates, keepPruned) {
+  const working = [...candidates];
+  working.sort((a, b) => a.distance - b.distance);
+  const selected = [];
+  const discarded = [];
+  for (const candidate of working) {
+    if (selected.length >= maxConnections) break;
+    let accepted = true;
+    for (const sel of selected) {
+      const distBetween = nodeDistanceByOrd(state, candidate.ord, sel.ord, metric);
+      if (candidate.distance >= distBetween) {
+        accepted = false;
+        break;
+      }
+    }
+    if (accepted) {
+      selected.push(candidate);
+    } else {
+      discarded.push(candidate);
+    }
+  }
+  {
+    for (const disc of discarded) {
+      if (selected.length >= maxConnections) break;
+      selected.push(disc);
+    }
+  }
+  return selected;
+}
+function pruneConnections(state, ord, layer, metric) {
+  const node = state.nodesByOrd[ord];
+  if (!node) return;
+  const mc = maxConns(state, layer);
+  if (node.connections[layer].length <= mc) return;
+  const conns = [];
+  for (const connOrd of node.connections[layer]) {
+    const dist = nodeDistanceByOrd(state, ord, connOrd, metric);
+    if (dist === Number.POSITIVE_INFINITY) continue;
+    conns.push({ ord: connOrd, distance: dist });
+  }
+  const pruned = selectNeighborsHeuristic(state, ord, conns, mc, layer, metric);
+  const next = [];
+  for (const p of pruned) addConnection(next, p.ord);
+  node.connections[layer] = next;
+}
+
+// src/vector/hnsw/mutation.ts
+function removeFromArray(arr, ord) {
+  const idx = arr.indexOf(ord);
+  if (idx !== -1) arr.splice(idx, 1);
+}
+function clearTombstone(state, ord) {
+  if (state.tombstones[ord] === 1) {
+    state.tombstones[ord] = 0;
+    state.tombstoneCount--;
+  }
+}
+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;
+    if (state.tombstones[ord] === 1) continue;
+    if (n.maxLayer > bestLayer) {
+      bestLayer = n.maxLayer;
+      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;
+        bestOrd = ord;
+      }
+    }
+  }
+  state.entryPointOrd = bestOrd;
+  state.topLayer = bestOrd === -1 ? -1 : bestLayer;
+}
+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 (state.nodesByOrd[ord] !== void 0) {
+    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;
+  state.nodeCount++;
+  if (state.entryPointOrd === -1) {
+    state.entryPointOrd = ord;
+    state.topLayer = l;
+    return;
+  }
+  const metric = state.buildMetric;
+  const insertDistFn = (candOrd) => nodeDistanceByOrd(state, ord, candOrd, metric);
+  let currentEPs = [state.entryPointOrd];
+  for (let layer = state.topLayer; layer > l; layer--) {
+    const heap = searchLayer(state, entry.vector, entry.magnitude, currentEPs, 1, layer, metric, false, insertDistFn);
+    const nearest = nearestFromHeap(heap);
+    if (nearest) {
+      currentEPs = [nearest.ord];
+    }
+  }
+  for (let layer = Math.min(l, state.topLayer); layer >= 0; layer--) {
+    const heap = searchLayer(
+      state,
+      entry.vector,
+      entry.magnitude,
+      currentEPs,
+      state.efCons,
+      layer,
+      metric,
+      false,
+      insertDistFn
+    );
+    const candidates = heap.toSortedArray().reverse();
+    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);
+        pruneConnections(state, neighbor.ord, layer, metric);
+      }
+    }
+    if (candidates.length > 0) {
+      currentEPs = candidates.map((n) => n.ord);
+    }
+  }
+  if (l > state.topLayer) {
+    state.entryPointOrd = ord;
+    state.topLayer = l;
+  }
+}
+function removeNodeEager(state, ord, excludeOrds) {
+  const node = state.nodesByOrd[ord];
+  if (!node) 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 (const neighborOrd of formerNeighbors) {
+      const neighborNode = state.nodesByOrd[neighborOrd];
+      if (neighborNode && layer < neighborNode.connections.length) {
+        removeFromArray(neighborNode.connections[layer], ord);
+      }
+    }
+    for (const neighborOrd of formerNeighbors) {
+      const neighborNode = state.nodesByOrd[neighborOrd];
+      if (!neighborNode || layer >= neighborNode.connections.length) continue;
+      const mc = maxConns(state, layer);
+      if (neighborNode.connections[layer].length >= mc) continue;
+      const candidateOrds = new Set(neighborNode.connections[layer]);
+      for (const otherOrd of formerNeighbors) {
+        if (otherOrd !== neighborOrd && otherOrd !== ord) {
+          if (excludeOrds?.has(otherOrd)) continue;
+          candidateOrds.add(otherOrd);
+        }
+      }
+      const candidates = [];
+      for (const candOrd of candidateOrds) {
+        const dist = nodeDistanceByOrd(state, neighborOrd, candOrd, metric);
+        if (dist === Number.POSITIVE_INFINITY) continue;
+        candidates.push({ ord: candOrd, distance: dist });
+      }
+      const selected = selectNeighborsHeuristic(state, neighborOrd, candidates, mc, layer, metric);
+      const newConns = [];
+      for (const s of selected) addConnection(newConns, s.ord);
+      neighborNode.connections[layer] = newConns;
+      for (const newConnOrd of newConns) {
+        const newConnNode = state.nodesByOrd[newConnOrd];
+        if (newConnNode && layer < newConnNode.connections.length) {
+          addConnection(newConnNode.connections[layer], neighborOrd);
+          pruneConnections(state, newConnOrd, layer, metric);
+        }
+      }
+    }
+  }
+  state.nodesByOrd[ord] = void 0;
+  state.nodeCount--;
+  clearTombstone(state, ord);
+  if (state.entryPointOrd === ord) {
+    if (state.nodeCount === 0) {
+      state.entryPointOrd = -1;
+      state.topLayer = -1;
+      return;
+    }
+    reassignEntryPoint(state);
+  }
+}
+function markTombstone(state, docId) {
+  const ord = state.store.getOrdinal(docId);
+  if (ord === void 0 || state.nodesByOrd[ord] === void 0) return;
+  if (state.tombstones[ord] === 0) {
+    state.tombstones[ord] = 1;
+    state.tombstoneCount++;
+  }
+  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;
+      if (state.tombstones[o] === 1) continue;
+      if (n.maxLayer > bestLayer) {
+        bestLayer = n.maxLayer;
+        bestOrd = o;
+      }
+    }
+    if (bestOrd !== -1) {
+      state.entryPointOrd = bestOrd;
+      state.topLayer = bestLayer;
+    } else {
+      state.entryPointOrd = -1;
+      state.topLayer = -1;
+    }
+  }
+}
+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) {
+      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.nodesByOrd.length; ord++) {
+    if (state.nodesByOrd[ord] !== void 0 && state.tombstones[ord] !== 1) {
+      liveOrds.push(ord);
+    }
+  }
+  state.nodesByOrd = [];
+  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.nodesByOrd.length; ord++) {
+    const node = state.nodesByOrd[ord];
+    if (!node) 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++) {
+      const liveNeighbors = [];
+      for (const neighborOrd of node.connections[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, node.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 deserializeGraph(state, data) {
+  state.nodesByOrd = [];
+  state.tombstones.fill(0);
+  state.tombstoneCount = 0;
+  state.nodeCount = 0;
+  state.entryPointOrd = -1;
+  state.topLayer = -1;
+  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 }, () => []);
+    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;
+      }
+    }
+    const node = { maxLayer, connections };
+    state.nodesByOrd[ord] = node;
+    state.nodeCount++;
+    if (ord > maxOrd) maxOrd = ord;
+  }
+  if (maxOrd >= 0) {
+    ensureCapacity(state, maxOrd + 1);
+  }
+  if (data.entryPoint != null && data.entryPoint !== "") {
+    const epOrd = state.store.getOrdinal(data.entryPoint);
+    if (epOrd !== void 0 && state.nodesByOrd[epOrd] !== void 0) {
+      state.entryPointOrd = epOrd;
+      state.topLayer = data.maxLayer;
+    }
+  }
+  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;
+        bestOrd = ord;
+      }
+    }
+    state.entryPointOrd = bestOrd;
+    state.topLayer = bestLayer;
+  }
+}
+
+// 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;
+  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,
+    nodesByOrd: [],
+    tombstones: new Uint8Array(0),
+    tombstoneCount: 0,
+    nodeCount: 0,
+    capacity: 0,
+    visited: new Uint32Array(0),
+    visitStamp: 0,
+    entryPointOrd: -1,
+    topLayer: -1
+  };
+  function clear() {
+    state.nodesByOrd = [];
+    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.nodesByOrd.length; ord++) {
+      if (state.nodesByOrd[ord] === void 0) 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;
+    },
+    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;
+    },
+    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),
+    clear,
+    entries: entriesIterator,
+    compactionNeeded,
+    compactTombstones: () => compactTombstones(state),
+    rebuild: () => rebuild(state),
+    serialize: () => serializeGraph(state),
+    deserialize: (data) => deserializeGraph(state, data)
+  };
+}
+
+export { cosineSimilarityWithMagnitudes, createArenaSimd, createBoundedMaxHeap, createHNSWIndex, createVectorStore, dotProduct, euclideanDistance, isSimdAvailable, magnitude };