@delali/narsil 0.1.7 → 0.1.9

package/dist/chunk-VVORJOXR.mjs

@@ -1,759 +0,0 @@
-// src/vector/simd-wasm-binary.ts
-var SIMD_DISTANCE_WASM_BASE64 = "AGFzbQEAAAABDgJgA39/fwF9YAJ/fwF9AwUEAAEAAAUDAQABB1YFBm1lbW9yeQIAC2RvdF9wcm9kdWN0AAAJbWFnbml0dWRlAAEac3F1YXJlZF9ldWNsaWRlYW5fZGlzdGFuY2UAAhJldWNsaWRlYW5fZGlzdGFuY2UAAwqqBASuAQQBfwF7AX0BfyACQXxxIQb9DAAAAAAAAAAAAAAAAAAAAAAhBEEAIQMCQANAIAMgBk8NASAEIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eYB/eQBIQQgA0EEaiEDDAALCyAE/R8AIAT9HwGSIAT9HwIgBP0fA5KSIQUCQANAIAMgAk8NASAFIAAgA0ECdGoqAgAgASADQQJ0aioCAJSSIQUgA0EBaiEDDAALCyAFC6kBBAF/AnsBfQF/IAFBfHEhBv0MAAAAAAAAAAAAAAAAAAAAACEDQQAhAgJAA0AgAiAGTw0BIAAgAkECdGr9AAQAIQQgAyAEIAT95gH95AEhAyACQQRqIQIMAAsLIAP9HwAgA/0fAZIgA/0fAiAD/R8DkpIhBQJAA0AgAiABTw0BIAUgACACQQJ0aioCACAAIAJBAnRqKgIAlJIhBSACQQFqIQIMAAsLIAWRC8ABBQF/AnsBfQF/AX0gAkF8cSEH/QwAAAAAAAAAAAAAAAAAAAAAIQRBACEDAkADQCADIAdPDQEgACADQQJ0av0ABAAgASADQQJ0av0ABAD95QEhBSAEIAUgBf3mAf3kASEEIANBBGohAwwACwsgBP0fACAE/R8BkiAE/R8CIAT9HwOSkiEGAkADQCADIAJPDQEgACADQQJ0aioCACABIANBAnRqKgIAkyEIIAYgCCAIlJIhBiADQQFqIQMMAAsLIAYLCwAgACABIAIQApEL";
-
-// 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;
-}
-
-// 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/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/hnsw.ts
-var MAX_LAYER_CAP = 32;
-var COMPACTION_TOMBSTONE_RATIO = 0.1;
-var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
-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;
-var SQ8_OVERSELECTION_FACTOR = 2;
-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 nodes = /* @__PURE__ */ new Map();
-  const tombstones = /* @__PURE__ */ new Set();
-  let entryPointId = null;
-  let topLayer = -1;
-  function randomLevel() {
-    let u = Math.random();
-    if (u === 0) u = Number.MIN_VALUE;
-    return Math.min(Math.floor(-Math.log(u) * mL), MAX_LAYER_CAP);
-  }
-  function getEntry(docId) {
-    return store.get(docId);
-  }
-  function nodeDistance(aId, bId, metric) {
-    const a = getEntry(aId);
-    const b = getEntry(bId);
-    if (!a || !b) return Number.POSITIVE_INFINITY;
-    return toDistance(a.vector, b.vector, a.magnitude, b.magnitude, metric);
-  }
-  function queryDistance(qVec, qMag, nodeId, metric) {
-    const entry = getEntry(nodeId);
-    if (!entry) return Number.POSITIVE_INFINITY;
-    return toDistance(qVec, entry.vector, qMag, entry.magnitude, metric);
-  }
-  function maxConns(layer) {
-    return layer === 0 ? Mmax0 : M;
-  }
-  function searchLayer(qVec, qMag, eps, ef, layer, metric, skipTombstones, distFn) {
-    const getDistance = distFn ?? ((nodeId) => queryDistance(qVec, qMag, nodeId, metric));
-    const visited = /* @__PURE__ */ new Set();
-    const candidates = createMinHeap(distanceAsc);
-    const results = createMinHeap(distanceDesc);
-    let furthestDist = Number.POSITIVE_INFINITY;
-    for (const epId of eps) {
-      if (visited.has(epId)) continue;
-      visited.add(epId);
-      const node = nodes.get(epId);
-      if (!node) continue;
-      if (skipTombstones && tombstones.has(epId)) continue;
-      const dist = getDistance(epId);
-      if (dist === Number.POSITIVE_INFINITY) continue;
-      const pair = { docId: epId, 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 = nodes.get(nearest.docId);
-      if (!node || layer >= node.connections.length) continue;
-      for (const neighborId of node.connections[layer]) {
-        if (visited.has(neighborId)) continue;
-        visited.add(neighborId);
-        if (skipTombstones && tombstones.has(neighborId)) continue;
-        const neighborNode = nodes.get(neighborId);
-        if (!neighborNode) continue;
-        const dist = getDistance(neighborId);
-        if (dist === Number.POSITIVE_INFINITY) continue;
-        if (dist < furthestDist || results.size < ef) {
-          const pair = { docId: neighborId, 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(targetId, 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 = nodeDistance(candidate.docId, sel.docId, 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(nodeId, node, layer, metric) {
-    const mc = maxConns(layer);
-    if (node.connections[layer].size <= mc) return;
-    const conns = [];
-    for (const connId of node.connections[layer]) {
-      const dist = nodeDistance(nodeId, connId, metric);
-      if (dist === Number.POSITIVE_INFINITY) continue;
-      conns.push({ docId: connId, distance: dist });
-    }
-    const pruned = selectNeighborsHeuristic(nodeId, conns, mc, layer, metric);
-    node.connections[layer] = new Set(pruned.map((p) => p.docId));
-  }
-  function insertNode(docId) {
-    const vecEntry = store.get(docId);
-    if (!vecEntry) {
-      throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
-    }
-    if (vecEntry.vector.length !== dimension) {
-      throw new Error(`Vector dimension mismatch: expected ${dimension}, got ${vecEntry.vector.length}`);
-    }
-    if (nodes.has(docId)) {
-      removeNodeEager(docId);
-    }
-    tombstones.delete(docId);
-    const l = randomLevel();
-    const node = {
-      docId,
-      maxLayer: l,
-      connections: Array.from({ length: l + 1 }, () => /* @__PURE__ */ new Set())
-    };
-    nodes.set(docId, node);
-    if (entryPointId === null) {
-      entryPointId = docId;
-      topLayer = l;
-      return;
-    }
-    const metric = buildMetric;
-    let currentEPs = [entryPointId];
-    for (let layer = topLayer; layer > l; layer--) {
-      const heap = searchLayer(vecEntry.vector, vecEntry.magnitude, currentEPs, 1, layer, metric, false);
-      const nearest = nearestFromHeap(heap);
-      if (nearest) {
-        currentEPs = [nearest.docId];
-      }
-    }
-    for (let layer = Math.min(l, topLayer); layer >= 0; layer--) {
-      const heap = searchLayer(vecEntry.vector, vecEntry.magnitude, currentEPs, efCons, layer, metric, false);
-      const candidates = heap.toSortedArray().reverse();
-      const mc = maxConns(layer);
-      const neighbors = selectNeighborsHeuristic(docId, candidates, mc, layer, metric);
-      for (const neighbor of neighbors) {
-        node.connections[layer].add(neighbor.docId);
-        const neighborNode = nodes.get(neighbor.docId);
-        if (neighborNode && layer < neighborNode.connections.length) {
-          neighborNode.connections[layer].add(docId);
-          pruneConnections(neighbor.docId, neighborNode, layer, metric);
-        }
-      }
-      if (candidates.length > 0) {
-        currentEPs = candidates.map((n) => n.docId);
-      }
-    }
-    if (l > topLayer) {
-      entryPointId = docId;
-      topLayer = l;
-    }
-  }
-  function removeNodeEager(docId, excludeDocIds) {
-    const node = nodes.get(docId);
-    if (!node) return;
-    const metric = buildMetric;
-    for (let layer = 0; layer <= node.maxLayer; layer++) {
-      if (layer >= node.connections.length) continue;
-      const formerNeighborIds = new Set(node.connections[layer]);
-      for (const neighborId of formerNeighborIds) {
-        const neighborNode = nodes.get(neighborId);
-        if (neighborNode && layer < neighborNode.connections.length) {
-          neighborNode.connections[layer].delete(docId);
-        }
-      }
-      for (const neighborId of formerNeighborIds) {
-        const neighborNode = nodes.get(neighborId);
-        if (!neighborNode || layer >= neighborNode.connections.length) continue;
-        const mc = maxConns(layer);
-        if (neighborNode.connections[layer].size >= mc) continue;
-        const candidateIds = new Set(neighborNode.connections[layer]);
-        for (const otherId of formerNeighborIds) {
-          if (otherId !== neighborId && otherId !== docId) {
-            if (excludeDocIds?.has(otherId)) continue;
-            candidateIds.add(otherId);
-          }
-        }
-        const candidates = [];
-        for (const candId of candidateIds) {
-          const dist = nodeDistance(neighborId, candId, metric);
-          if (dist === Number.POSITIVE_INFINITY) continue;
-          candidates.push({ docId: candId, distance: dist });
-        }
-        const selected = selectNeighborsHeuristic(neighborId, candidates, mc, layer, metric);
-        const newConns = new Set(selected.map((s) => s.docId));
-        neighborNode.connections[layer] = newConns;
-        for (const newConnId of newConns) {
-          const newConnNode = nodes.get(newConnId);
-          if (newConnNode && layer < newConnNode.connections.length) {
-            newConnNode.connections[layer].add(neighborId);
-            pruneConnections(newConnId, newConnNode, layer, metric);
-          }
-        }
-      }
-    }
-    nodes.delete(docId);
-    if (entryPointId === docId) {
-      if (nodes.size === 0) {
-        entryPointId = null;
-        topLayer = -1;
-        return;
-      }
-      let newEntryId = null;
-      let newTopLayer = -1;
-      for (const [nId, n] of nodes) {
-        if (tombstones.has(nId)) continue;
-        if (n.maxLayer > newTopLayer) {
-          newTopLayer = n.maxLayer;
-          newEntryId = nId;
-        }
-      }
-      if (newEntryId === null) {
-        for (const [nId, n] of nodes) {
-          if (n.maxLayer > newTopLayer) {
-            newTopLayer = n.maxLayer;
-            newEntryId = nId;
-          }
-        }
-      }
-      entryPointId = newEntryId;
-      topLayer = newTopLayer;
-    }
-  }
-  function markTombstone(docId) {
-    if (!nodes.has(docId)) return;
-    tombstones.add(docId);
-    if (entryPointId === docId) {
-      let newEntryId = null;
-      let newTopLayer = -1;
-      for (const [nId, n] of nodes) {
-        if (tombstones.has(nId)) continue;
-        if (n.maxLayer > newTopLayer) {
-          newTopLayer = n.maxLayer;
-          newEntryId = nId;
-        }
-      }
-      if (newEntryId !== null) {
-        entryPointId = newEntryId;
-        topLayer = newTopLayer;
-      } else {
-        entryPointId = null;
-        topLayer = -1;
-      }
-    }
-  }
-  function search(query, k, searchMetric, minSimilarity, filterDocIds, efSearch) {
-    if (query.length !== dimension) {
-      throw new Error(`Query dimension mismatch: expected ${dimension}, got ${query.length}`);
-    }
-    const liveSize = nodes.size - tombstones.size;
-    if (entryPointId === null || liveSize === 0) {
-      return [];
-    }
-    const useQuantized = quantizer?.isCalibrated() === true && quantizer.size > 0;
-    const defaultEf = 50;
-    let ef = Math.max(efSearch ?? defaultEf, k);
-    if (filterDocIds && filterDocIds.size < liveSize) {
-      const selectivity = filterDocIds.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;
-    let prepared = null;
-    if (useQuantized && quantizer) {
-      prepared = quantizer.prepareQuery(query);
-      if (prepared) {
-        const p = prepared;
-        const metric = searchMetric;
-        const q = quantizer;
-        quantizedDistFn = (nodeId) => q.distanceFromPrepared(p, nodeId, metric);
-      }
-    }
-    let currentEPs = [entryPointId];
-    for (let layer = topLayer; layer >= 1; layer--) {
-      const heap = searchLayer(query, qMag, currentEPs, 1, layer, searchMetric, true, quantizedDistFn);
-      const nearest = nearestFromHeap(heap);
-      if (nearest) {
-        currentEPs = [nearest.docId];
-      }
-    }
-    const candidateHeap = searchLayer(query, qMag, currentEPs, ef, 0, searchMetric, true, quantizedDistFn);
-    const candidateArray = candidateHeap.toSortedArray().reverse();
-    if (useQuantized) {
-      return rerankWithFullPrecision(candidateArray, query, qMag, k, searchMetric, minSimilarity, filterDocIds);
-    }
-    const results = [];
-    for (const cand of candidateArray) {
-      if (filterDocIds && !filterDocIds.has(cand.docId)) continue;
-      const score = toScore(cand.distance, searchMetric);
-      if (score < minSimilarity) continue;
-      results.push({
-        docId: cand.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(candidates, query, qMag, k, metric, minSimilarity, filterDocIds) {
-    const reranked = [];
-    const rerankLimit = Math.max(k * SQ8_OVERSELECTION_FACTOR, 10);
-    for (const cand of candidates) {
-      if (filterDocIds && !filterDocIds.has(cand.docId)) continue;
-      const entry = getEntry(cand.docId);
-      if (!entry) continue;
-      const fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
-      const score = toScore(fullDistance, metric);
-      if (score < minSimilarity) continue;
-      reranked.push({
-        docId: cand.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);
-  }
-  function serialize() {
-    const nodeArray = [];
-    for (const [docId, node] of nodes) {
-      if (tombstones.has(docId)) continue;
-      const layerConns = [];
-      for (let layer = 0; layer < node.connections.length; layer++) {
-        const liveNeighbors = Array.from(node.connections[layer]).filter((id) => !tombstones.has(id));
-        if (liveNeighbors.length > 0) {
-          layerConns.push([layer, liveNeighbors]);
-        }
-      }
-      nodeArray.push([docId, node.maxLayer, layerConns]);
-    }
-    return {
-      entryPoint: entryPointId,
-      maxLayer: topLayer,
-      m: M,
-      efConstruction: efCons,
-      metric: buildMetric,
-      nodes: nodeArray
-    };
-  }
-  function deserialize(data) {
-    nodes.clear();
-    tombstones.clear();
-    for (const [docId, maxLayer, layerConns] of data.nodes) {
-      const vecData = store.get(docId);
-      if (!vecData) continue;
-      const connections = Array.from({ length: maxLayer + 1 }, () => /* @__PURE__ */ new Set());
-      for (const [layer, neighbors] of layerConns) {
-        if (layer < connections.length) {
-          connections[layer] = new Set(neighbors);
-        }
-      }
-      nodes.set(docId, { docId, maxLayer, connections });
-    }
-    if (data.entryPoint != null && data.entryPoint !== "" && nodes.has(data.entryPoint)) {
-      entryPointId = data.entryPoint;
-      topLayer = data.maxLayer;
-    } else if (nodes.size > 0) {
-      let bestId = null;
-      let bestLayer = -1;
-      for (const [nId, n] of nodes) {
-        if (n.maxLayer > bestLayer) {
-          bestLayer = n.maxLayer;
-          bestId = nId;
-        }
-      }
-      entryPointId = bestId;
-      topLayer = bestLayer;
-    } else {
-      entryPointId = null;
-      topLayer = -1;
-    }
-  }
-  function clear() {
-    nodes.clear();
-    tombstones.clear();
-    entryPointId = null;
-    topLayer = -1;
-  }
-  function* entriesIterator() {
-    for (const [docId] of nodes) {
-      if (tombstones.has(docId)) continue;
-      const entry = store.get(docId);
-      if (!entry) continue;
-      yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
-    }
-  }
-  function compactionNeeded() {
-    if (nodes.size === 0) return false;
-    return tombstones.size / nodes.size > COMPACTION_TOMBSTONE_RATIO || tombstones.size > COMPACTION_ABSOLUTE_THRESHOLD;
-  }
-  function compactTombstones() {
-    if (tombstones.size === 0) return;
-    const tombstonedDocIds = Array.from(tombstones);
-    for (const docId of tombstonedDocIds) {
-      removeNodeEager(docId, tombstones);
-    }
-    tombstones.clear();
-  }
-  function rebuild() {
-    if (tombstones.size === 0 && nodes.size === 0) return;
-    const liveDocIds = [];
-    for (const [docId] of nodes) {
-      if (!tombstones.has(docId)) {
-        liveDocIds.push(docId);
-      }
-    }
-    clear();
-    for (const docId of liveDocIds) {
-      const entry = store.get(docId);
-      if (!entry) continue;
-      insertNode(docId);
-    }
-  }
-  return {
-    get dimension() {
-      return dimension;
-    },
-    get size() {
-      return nodes.size - tombstones.size;
-    },
-    get tombstoneCount() {
-      return tombstones.size;
-    },
-    get entryPointId() {
-      return entryPointId;
-    },
-    get topLayer() {
-      return topLayer;
-    },
-    get m() {
-      return M;
-    },
-    get efConstruction() {
-      return efCons;
-    },
-    get metric() {
-      return buildMetric;
-    },
-    insertNode,
-    markTombstone,
-    has: (docId) => nodes.has(docId) && !tombstones.has(docId),
-    isTombstoned: (docId) => tombstones.has(docId),
-    search,
-    clear,
-    entries: entriesIterator,
-    compactionNeeded,
-    compactTombstones,
-    rebuild,
-    serialize,
-    deserialize
-  };
-}
-
-// src/vector/vector-store.ts
-function createVectorStore() {
-  const vectors = /* @__PURE__ */ new Map();
-  return {
-    get size() {
-      return vectors.size;
-    },
-    insert(docId, vector) {
-      const mag = magnitude(vector);
-      vectors.set(docId, { vector, magnitude: mag });
-    },
-    remove(docId) {
-      vectors.delete(docId);
-    },
-    get(docId) {
-      return vectors.get(docId);
-    },
-    has(docId) {
-      return vectors.has(docId);
-    },
-    entries() {
-      return vectors.entries();
-    },
-    clear() {
-      vectors.clear();
-    },
-    estimateMemory(dimension) {
-      const count = vectors.size;
-      if (count === 0) return 0;
-      const MAP_OVERHEAD = 64;
-      const MAP_ENTRY = 72;
-      const ENTRY_OBJ = 32;
-      const AVG_DOCID_BYTES = 56;
-      const TYPED_ARRAY_HEADER = 64;
-      const MAGNITUDE_BYTES = 8;
-      const perEntry = MAP_ENTRY + ENTRY_OBJ + AVG_DOCID_BYTES + TYPED_ARRAY_HEADER + MAGNITUDE_BYTES;
-      return MAP_OVERHEAD + count * (perEntry + dimension * 4);
-    }
-  };
-}
-
-export { cosineSimilarityWithMagnitudes, createBoundedMaxHeap, createHNSWIndex, createVectorStore, dotProduct, euclideanDistance, isSimdAvailable, magnitude };