@delali/narsil 0.1.6 → 0.1.7

package/dist/{chunk-7GKPWGCN.mjs → chunk-R2C2EQGO.mjs}

@@ -21,13 +21,20 @@ var ErrorCodes = {
   PERSISTENCE_CRC_MISMATCH: "PERSISTENCE_CRC_MISMATCH",
   SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD",
   SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE",
+  VECTOR_DIMENSION_MISMATCH: "VECTOR_DIMENSION_MISMATCH",
   SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER",
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
   SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR",
   LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED",
   ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH",
   ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC",
-  PARTITION_CAPACITY_EXCEEDED: "PARTITION_CAPACITY_EXCEEDED"
+  PARTITION_CAPACITY_EXCEEDED: "PARTITION_CAPACITY_EXCEEDED",
+  EMBEDDING_FAILED: "EMBEDDING_FAILED",
+  EMBEDDING_DIMENSION_MISMATCH: "EMBEDDING_DIMENSION_MISMATCH",
+  EMBEDDING_NO_SOURCE: "EMBEDDING_NO_SOURCE",
+  EMBEDDING_CONFIG_INVALID: "EMBEDDING_CONFIG_INVALID",
+  DOC_MISSING_REQUIRED_FIELD: "DOC_MISSING_REQUIRED_FIELD",
+  CONFIG_INVALID: "CONFIG_INVALID"
 };
 var NarsilError = class extends Error {
   code;
@@ -39,5 +46,8 @@ var NarsilError = class extends Error {
     this.details = details ?? {};
   }
 };
+function createNarsilError(code, message, details) {
+  return new NarsilError(code, message, details);
+}
 
-export { ErrorCodes, NarsilError };
+export { ErrorCodes, NarsilError, createNarsilError };

package/dist/{chunk-GVN2W4VA.mjs → chunk-VVORJOXR.mjs}

@@ -80,6 +80,32 @@ function isSimdAvailable() {
 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) {
@@ -170,6 +196,8 @@ function euclideanDistance(a, b) {
 
 // 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":
@@ -192,13 +220,15 @@ function toScore(distance, metric) {
 }
 var distanceAsc = (a, b) => a.distance - b.distance;
 var distanceDesc = (a, b) => b.distance - a.distance;
-function createHNSWIndex(dimension, config) {
+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() {
@@ -206,16 +236,25 @@ function createHNSWIndex(dimension, config) {
     if (u === 0) u = Number.MIN_VALUE;
     return Math.min(Math.floor(-Math.log(u) * mL), MAX_LAYER_CAP);
   }
-  function nodeDistance(a, b, metric) {
-    return toDistance(a.vector, b.vector, a.mag, b.mag, metric);
+  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, node, metric) {
-    return toDistance(qVec, node.vector, qMag, node.mag, 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) {
+  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);
@@ -225,7 +264,9 @@ function createHNSWIndex(dimension, config) {
       visited.add(epId);
       const node = nodes.get(epId);
       if (!node) continue;
-      const dist = queryDistance(qVec, qMag, node, metric);
+      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);
@@ -244,9 +285,11 @@ function createHNSWIndex(dimension, config) {
       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 = queryDistance(qVec, qMag, neighborNode, metric);
+        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);
@@ -259,20 +302,25 @@ function createHNSWIndex(dimension, config) {
         }
       }
     }
-    return results.toSortedArray();
+    return results;
+  }
+  function nearestFromHeap(heap) {
+    let nearest;
+    while (heap.size > 0) {
+      nearest = heap.pop();
+    }
+    return nearest;
   }
-  function selectNeighborsHeuristic(targetVec, targetMag, candidates, maxConnections, layer, metric, extendCandidates, keepPruned) {
-    const working = [...candidates].sort((a, b) => a.distance - b.distance);
+  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 selNode = nodes.get(sel.docId);
-        const candNode = nodes.get(candidate.docId);
-        if (!selNode || !candNode) continue;
-        const distBetween = nodeDistance(candNode, selNode, metric);
+        const distBetween = nodeDistance(candidate.docId, sel.docId, metric);
         if (candidate.distance >= distBetween) {
           accepted = false;
           break;
@@ -292,34 +340,33 @@ function createHNSWIndex(dimension, config) {
     }
     return selected;
   }
-  function pruneConnections(node, layer, metric) {
+  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 connNode = nodes.get(connId);
-      if (!connNode) continue;
-      conns.push({
-        docId: connId,
-        distance: nodeDistance(node, connNode, metric)
-      });
+      const dist = nodeDistance(nodeId, connId, metric);
+      if (dist === Number.POSITIVE_INFINITY) continue;
+      conns.push({ docId: connId, distance: dist });
     }
-    const pruned = selectNeighborsHeuristic(node.vector, node.mag, conns, mc, layer, metric);
+    const pruned = selectNeighborsHeuristic(nodeId, conns, mc, layer, metric);
     node.connections[layer] = new Set(pruned.map((p) => p.docId));
   }
-  function insert(docId, vector) {
-    if (vector.length !== dimension) {
-      throw new Error(`Vector dimension mismatch: expected ${dimension}, got ${vector.length}`);
+  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)) {
-      remove(docId);
+      removeNodeEager(docId);
     }
-    const mag = magnitude(vector);
+    tombstones.delete(docId);
     const l = randomLevel();
     const node = {
       docId,
-      vector,
-      mag,
       maxLayer: l,
       connections: Array.from({ length: l + 1 }, () => /* @__PURE__ */ new Set())
     };
@@ -332,25 +379,27 @@ function createHNSWIndex(dimension, config) {
     const metric = buildMetric;
     let currentEPs = [entryPointId];
     for (let layer = topLayer; layer > l; layer--) {
-      const nearest = searchLayer(vector, mag, currentEPs, 1, layer, metric);
-      if (nearest.length > 0) {
-        currentEPs = [nearest[0].docId];
+      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 nearest = searchLayer(vector, mag, currentEPs, efCons, layer, metric);
-      const neighbors = selectNeighborsHeuristic(vector, mag, nearest, mc, layer, metric);
+      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(neighborNode, layer, metric);
+          pruneConnections(neighbor.docId, neighborNode, layer, metric);
         }
       }
-      if (nearest.length > 0) {
-        currentEPs = nearest.map((n) => n.docId);
+      if (candidates.length > 0) {
+        currentEPs = candidates.map((n) => n.docId);
       }
     }
     if (l > topLayer) {
@@ -358,7 +407,7 @@ function createHNSWIndex(dimension, config) {
       topLayer = l;
     }
   }
-  function remove(docId) {
+  function removeNodeEager(docId, excludeDocIds) {
     const node = nodes.get(docId);
     if (!node) return;
     const metric = buildMetric;
@@ -379,32 +428,24 @@ function createHNSWIndex(dimension, config) {
         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 candNode = nodes.get(candId);
-          if (!candNode) continue;
-          candidates.push({
-            docId: candId,
-            distance: nodeDistance(neighborNode, candNode, metric)
-          });
+          const dist = nodeDistance(neighborId, candId, metric);
+          if (dist === Number.POSITIVE_INFINITY) continue;
+          candidates.push({ docId: candId, distance: dist });
         }
-        const selected = selectNeighborsHeuristic(
-          neighborNode.vector,
-          neighborNode.mag,
-          candidates,
-          mc,
-          layer,
-          metric);
+        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(newConnNode, layer, metric);
+            pruneConnections(newConnId, newConnNode, layer, metric);
           }
         }
       }
@@ -419,39 +460,89 @@ function createHNSWIndex(dimension, config) {
       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}`);
     }
-    if (entryPointId === null || nodes.size === 0) {
+    const liveSize = nodes.size - tombstones.size;
+    if (entryPointId === null || liveSize === 0) {
       return [];
     }
-    let ef = Math.max(efSearch ?? 50, k);
-    if (filterDocIds && filterDocIds.size < nodes.size) {
-      const selectivity = filterDocIds.size / nodes.size;
+    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, nodes.size);
+      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 nearest = searchLayer(query, qMag, currentEPs, 1, layer, searchMetric);
-      if (nearest.length > 0) {
-        currentEPs = [nearest[0].docId];
+      const heap = searchLayer(query, qMag, currentEPs, 1, layer, searchMetric, true, quantizedDistFn);
+      const nearest = nearestFromHeap(heap);
+      if (nearest) {
+        currentEPs = [nearest.docId];
       }
     }
-    const candidates = searchLayer(query, qMag, currentEPs, ef, 0, searchMetric);
+    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 candidates) {
+    for (const cand of candidateArray) {
       if (filterDocIds && !filterDocIds.has(cand.docId)) continue;
       const score = toScore(cand.distance, searchMetric);
       if (score < minSimilarity) continue;
@@ -463,22 +554,46 @@ function createHNSWIndex(dimension, config) {
         idf: {}
       });
     }
-    results.sort((a, b) => b.score - a.score);
+    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++) {
-        if (node.connections[layer].size > 0) {
-          layerConns.push([layer, Array.from(node.connections[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 ?? "",
+      entryPoint: entryPointId,
       maxLayer: topLayer,
       m: M,
       efConstruction: efCons,
@@ -486,10 +601,11 @@ function createHNSWIndex(dimension, config) {
       nodes: nodeArray
     };
   }
-  function deserialize(data, vectors) {
+  function deserialize(data) {
     nodes.clear();
+    tombstones.clear();
     for (const [docId, maxLayer, layerConns] of data.nodes) {
-      const vecData = vectors.get(docId);
+      const vecData = store.get(docId);
       if (!vecData) continue;
       const connections = Array.from({ length: maxLayer + 1 }, () => /* @__PURE__ */ new Set());
       for (const [layer, neighbors] of layerConns) {
@@ -497,15 +613,9 @@ function createHNSWIndex(dimension, config) {
           connections[layer] = new Set(neighbors);
         }
       }
-      nodes.set(docId, {
-        docId,
-        vector: vecData.vector,
-        mag: vecData.mag,
-        maxLayer,
-        connections
-      });
+      nodes.set(docId, { docId, maxLayer, connections });
     }
-    if (data.entryPoint && nodes.has(data.entryPoint)) {
+    if (data.entryPoint != null && data.entryPoint !== "" && nodes.has(data.entryPoint)) {
       entryPointId = data.entryPoint;
       topLayer = data.maxLayer;
     } else if (nodes.size > 0) {
@@ -526,12 +636,43 @@ function createHNSWIndex(dimension, config) {
   }
   function clear() {
     nodes.clear();
+    tombstones.clear();
     entryPointId = null;
     topLayer = -1;
   }
   function* entriesIterator() {
-    for (const [docId, node] of nodes) {
-      yield [docId, { docId, vector: node.vector, magnitude: node.mag }];
+    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 {
@@ -539,7 +680,10 @@ function createHNSWIndex(dimension, config) {
       return dimension;
     },
     get size() {
-      return nodes.size;
+      return nodes.size - tombstones.size;
+    },
+    get tombstoneCount() {
+      return tombstones.size;
     },
     get entryPointId() {
       return entryPointId;
@@ -556,15 +700,60 @@ function createHNSWIndex(dimension, config) {
     get metric() {
       return buildMetric;
     },
-    insert,
-    remove,
-    has: (docId) => nodes.has(docId),
+    insertNode,
+    markTombstone,
+    has: (docId) => nodes.has(docId) && !tombstones.has(docId),
+    isTombstoned: (docId) => tombstones.has(docId),
     search,
     clear,
     entries: entriesIterator,
+    compactionNeeded,
+    compactTombstones,
+    rebuild,
     serialize,
     deserialize
   };
 }
 
-export { cosineSimilarityWithMagnitudes, createHNSWIndex, dotProduct, euclideanDistance, isSimdAvailable, magnitude };
+// 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 };

package/dist/direct-executor-LBJLGMJ2.mjs

@@ -0,0 +1,4 @@
+export { createDirectExecutor } from './chunk-KHL4RPC3.mjs';
+import './chunk-VVORJOXR.mjs';
+import './chunk-I24SGLFS.mjs';
+import './chunk-R2C2EQGO.mjs';

package/dist/embeddings/openai.d.ts

@@ -0,0 +1,13 @@
+import { E as EmbeddingAdapter } from '../adapters-BbRkoiu9.js';
+
+interface OpenAIEmbeddingConfig {
+    baseUrl: string;
+    apiKey: string | (() => string | Promise<string>);
+    model: string;
+    dimensions: number;
+    timeout?: number;
+    maxRetries?: number;
+}
+declare function createOpenAIEmbedding(config: OpenAIEmbeddingConfig): EmbeddingAdapter;
+
+export { type OpenAIEmbeddingConfig, createOpenAIEmbedding };