@delali/narsil 0.2.4-next.45 → 0.2.4-next.47

package/dist/{chunk-OBXS7OZM.mjs → chunk-4COAUBLJ.mjs}

@@ -1,4 +1,4 @@
-import { createArenaSimd } from './chunk-WDL632CN.mjs';
+import { createArenaSimd } from './chunk-DFZDV5FV.mjs';
 
 // src/vector/scalar-quantization-math.ts
 function deriveSq8Constants(alpha, offset, dimensions) {

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

@@ -536,90 +536,6 @@ function createVectorStore() {
   };
 }
 
-// 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/adjacency.ts
 var MAX_LAYER_CAP = 32;
 var MAX_M = 512;
@@ -770,12 +686,12 @@ function removeNeighbor(adj, ord, layer, neighborOrd) {
     return;
   }
 }
-function replaceNeighbors(adj, ord, layer, neighbors) {
+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(neighbors.length, stride - 1);
+  const limit = Math.min(count, stride - 1);
   for (let i = 0; i < limit; i++) {
     array[base + i + 1] = neighbors[i];
   }
@@ -859,8 +775,6 @@ function toScore(distance, metric) {
       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;
@@ -887,37 +801,168 @@ function addConnection(connections, ord) {
   connections.push(ord);
 }
 
+// src/vector/hnsw/workspace.ts
+var INITIAL_LIST_CAPACITY = 64;
+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, eps, ef, layer, metric, skipTombstones, distFn) {
+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);
-  const candidates = createMinHeap(distanceAsc);
-  const results = createMinHeap(distanceDesc);
+  resetHeap(frontier);
+  resetHeap(found);
   let furthestDist = Number.POSITIVE_INFINITY;
-  for (const epOrd of eps) {
+  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;
-    const pair = { ord: epOrd, distance: dist };
-    candidates.push(pair);
-    results.push(pair);
-    if (results.size > ef) {
-      results.pop();
+    pushHeap(frontier, epOrd, dist);
+    pushHeap(found, epOrd, dist);
+    if (found.size > ef) {
+      popHeap(found);
     }
   }
-  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 base = layerBase(adjacency, nearest.ord, layer);
+  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++) {
@@ -928,55 +973,41 @@ function searchLayer(state, qVec, qMag, eps, ef, layer, metric, skipTombstones,
       if (!nodeExists(state, neighborOrd)) 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();
+      if (dist < furthestDist || found.size < ef) {
+        pushHeap(frontier, neighborOrd, dist);
+        pushHeap(found, neighborOrd, dist);
+        if (found.size > ef) {
+          popHeap(found);
         }
-        const newTop = results.peek();
-        if (newTop) furthestDist = newTop.distance;
+        furthestDist = found.distances[0];
       }
     }
   }
-  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;
+  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 (const sel of selected) {
-      const distBetween = nodeDistanceByOrd(state, candidate.ord, sel.ord, metric);
-      if (candidate.distance >= distBetween) {
+    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) {
-      selected.push(candidate);
-    } else {
-      discarded.push(candidate);
-    }
+    if (!accepted) continue;
+    selected.ords[selected.size] = candidateOrd;
+    selected.distances[selected.size] = candidateDistance;
+    selected.size += 1;
   }
-  {
-    for (const disc of discarded) {
-      if (selected.length >= maxConnections) break;
-      selected.push(disc);
-    }
-  }
-  return selected;
 }
 function pruneConnections(state, ord, layer, metric) {
   const adjacency = state.adjacency;
@@ -986,17 +1017,20 @@ function pruneConnections(state, ord, layer, metric) {
   const neighbors = layerArray(adjacency, layer);
   const count = neighbors[base];
   if (count <= mc) return;
-  const conns = [];
+  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;
-    conns.push({ ord: connOrd, distance: dist });
+    candidates.ords[candidates.size] = connOrd;
+    candidates.distances[candidates.size] = dist;
+    candidates.size += 1;
   }
-  const pruned = selectNeighborsHeuristic(state, ord, conns, mc, layer, metric);
-  const next = [];
-  for (const p of pruned) addConnection(next, p.ord);
-  replaceNeighbors(adjacency, ord, layer, next);
+  const kept = state.workspace.pruneSelection;
+  selectNeighborsHeuristic(state, candidates, mc, metric, kept);
+  replaceNeighbors(adjacency, ord, layer, kept.ords, kept.size);
 }
 
 // src/vector/hnsw/search.ts
@@ -1039,20 +1073,20 @@ function collectHits(state, query, k, searchMetric, minSimilarity, filter, efSea
     const metric = searchMetric;
     distFn = (ord) => store.distanceFromArena(arenaQuery, ord, metric);
   }
-  let currentEPs = [state.entryPointOrd];
+  const workspace = state.workspace;
+  const candidates = workspace.traversal;
+  setSingleEntryPoint(workspace, state.entryPointOrd);
   for (let layer = state.topLayer; layer >= 1; layer--) {
-    const heap = searchLayer(state, query, qMag, currentEPs, 1, layer, searchMetric, true, distFn);
-    const nearest = nearestFromHeap(heap);
-    if (nearest) {
-      currentEPs = [nearest.ord];
+    searchLayer(state, query, qMag, 1, layer, searchMetric, true, distFn, candidates);
+    if (candidates.size > 0) {
+      setSingleEntryPoint(workspace, candidates.ords[0]);
     }
   }
-  const candidateHeap = searchLayer(state, query, qMag, currentEPs, ef, 0, searchMetric, true, distFn);
-  const candidateArray = candidateHeap.toSortedArray().reverse();
+  searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates);
   if (useQuantized) {
     return rerankWithFullPrecision(
       state,
-      candidateArray,
+      candidates,
       query,
       qMag,
       arenaQuery,
@@ -1064,33 +1098,35 @@ function collectHits(state, query, k, searchMetric, minSimilarity, filter, efSea
     );
   }
   const hits = [];
-  for (const cand of candidateArray) {
-    if (filter && !ordinalFilterHas(filter, cand.ord)) continue;
-    const score = toScore(cand.distance, searchMetric);
+  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(cand.ord)) continue;
-    hits.push({ ord: cand.ord, score });
+    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, 10);
-  for (const cand of candidates) {
-    if (filter && !ordinalFilterHas(filter, cand.ord)) continue;
+  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, cand.ord, metric);
+      fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
       if (fullDistance === Number.POSITIVE_INFINITY) continue;
     } else {
-      const entry = entryForOrd(state, cand.ord);
+      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(cand.ord)) continue;
-    reranked.push({ ord: cand.ord, score });
+    if (!hasDocument(ord)) continue;
+    reranked.push({ ord, score });
     if (reranked.length >= rerankLimit) break;
   }
   return reranked;
@@ -1127,30 +1163,23 @@ function clearTombstone(state, ord) {
     state.tombstoneCount--;
   }
 }
-function reassignEntryPoint(state) {
+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 (state.tombstones[ord] === 1) continue;
+    if (!includeTombstoned && state.tombstones[ord] === 1) continue;
     if (level > bestLayer) {
       bestLayer = level;
       bestOrd = ord;
     }
   }
-  if (bestOrd === -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 = bestOrd === -1 ? -1 : bestLayer;
+  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);
@@ -1178,39 +1207,30 @@ function insertNode(state, docId) {
     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);
-  let currentEPs = [state.entryPointOrd];
+  setSingleEntryPoint(workspace, 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];
+    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--) {
-    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) {
-      addNeighbor(state.adjacency, ord, layer, neighbor.ord);
-      if (layer <= nodeMaxLayer(state, neighbor.ord)) {
-        addNeighbor(state.adjacency, neighbor.ord, layer, ord);
-        pruneConnections(state, neighbor.ord, layer, metric);
+    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.length > 0) {
-      currentEPs = candidates.map((n) => n.ord);
+    if (candidates.size > 0) {
+      setEntryPointsFromList(workspace, candidates);
     }
   }
   if (l > state.topLayer) {
@@ -1240,17 +1260,18 @@ function removeNodeEager(state, ord, excludeOrds) {
           candidateOrds.add(otherOrd);
         }
       }
-      const candidates = [];
+      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;
-        candidates.push({ ord: candOrd, distance: dist });
+        appendToList(candidates, candOrd, dist);
       }
-      const selected = selectNeighborsHeuristic(state, neighborOrd, candidates, mc, layer, metric);
-      const newConns = [];
-      for (const s of selected) addConnection(newConns, s.ord);
-      replaceNeighbors(state.adjacency, neighborOrd, layer, newConns);
-      for (const newConnOrd of newConns) {
+      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);
@@ -1263,11 +1284,11 @@ function removeNodeEager(state, ord, excludeOrds) {
   clearTombstone(state, ord);
   if (state.entryPointOrd === ord) {
     if (state.nodeCount === 0) {
-      state.entryPointOrd = -1;
-      state.topLayer = -1;
+      setEntryPoint(state, -1);
       return;
     }
-    reassignEntryPoint(state);
+    const live = highestNode(state, false);
+    setEntryPoint(state, live === -1 ? highestNode(state, true) : live);
   }
 }
 function markTombstone(state, docId) {
@@ -1278,24 +1299,7 @@ function markTombstone(state, docId) {
     state.tombstoneCount++;
   }
   if (state.entryPointOrd === ord) {
-    let bestOrd = -1;
-    let bestLayer = -1;
-    for (let o = 0; o < state.adjacency.slots; o++) {
-      const level = nodeMaxLayer(state, o);
-      if (level === -1) continue;
-      if (state.tombstones[o] === 1) continue;
-      if (level > bestLayer) {
-        bestLayer = level;
-        bestOrd = o;
-      }
-    }
-    if (bestOrd !== -1) {
-      state.entryPointOrd = bestOrd;
-      state.topLayer = bestLayer;
-    } else {
-      state.entryPointOrd = -1;
-      state.topLayer = -1;
-    }
+    setEntryPoint(state, highestNode(state, false));
   }
 }
 function compactTombstones(state) {
@@ -1408,7 +1412,7 @@ function deserializeGraph(state, data) {
   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);
+      replaceNeighbors(state.adjacency, node.ord, layer, neighbors, neighbors.length);
     }
     state.nodeCount++;
   }
@@ -1459,7 +1463,8 @@ function createHNSWIndex(dimension, store, config, quantizer) {
     visited: new Uint32Array(0),
     visitStamp: 0,
     entryPointOrd: -1,
-    topLayer: -1
+    topLayer: -1,
+    workspace: createHNSWWorkspace()
   };
   function clear() {
     resetAdjacency(state.adjacency);
@@ -1560,4 +1565,4 @@ function createHNSWIndex(dimension, store, config, quantizer) {
   };
 }
 
-export { ABSENT_DOCUMENT_RANK, MAX_M, addToOrdinalFilter, arenaFloat32Distance, cosineSimilarityWithMagnitudes, createArenaSimd, createBoundedMaxHeap, createHNSWIndex, createOrdinalFilter, createSharedArenaSimd, createVectorStore, dotProduct, euclideanDistance, importAdjacency, isSimdAvailable, magnitude, ordinalFilterHas, ordinalFilterValues, removeFromOrdinalFilter, searchOrdinals, toScore };
+export { ABSENT_DOCUMENT_RANK, MAX_M, addToOrdinalFilter, arenaFloat32Distance, cosineSimilarityWithMagnitudes, createArenaSimd, createHNSWIndex, createHNSWWorkspace, createOrdinalFilter, createSharedArenaSimd, createVectorStore, dotProduct, euclideanDistance, importAdjacency, isSimdAvailable, magnitude, ordinalFilterHas, ordinalFilterValues, removeFromOrdinalFilter, searchOrdinals, toScore };