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

package/dist/chunk-T62YOSGS.mjs

@@ -0,0 +1,4280 @@
+import { OSQ_STEPS, OSQ_GRID, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ4_NARROW_DIMENSION_LIMIT, DEFAULT_OSQ4_NARROW_OVERSAMPLE, DEFAULT_OVERSAMPLE_BY_BITS, OSQ_QUERY_BITS, OSQ_LAMBDA } from './chunk-ZJ4CSAB2.mjs';
+import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-WFKIGEBY.mjs';
+import { compareCodePoints } from './chunk-2GWVQWGA.mjs';
+import { NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import { existsSync, readSync, closeSync, openSync } from 'fs';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+
+// src/vector/constants.ts
+var WASM_PAGE_BYTES = 65536;
+var MAX_WASM_PAGES = 65536;
+var VECTOR_STORE_INITIAL_CAPACITY = 16;
+var VECTOR_BLOCK_INITIAL_SLOTS = 256;
+var DISK_STORAGE_BLOCK_BYTES = 67108864;
+var MAX_VECTOR_ORDINALS = 16777216;
+var VECTOR_SCRATCH_SLOTS = 64;
+var SCRATCH_SLOTS_PER_THREAD_POOL = 31;
+var MAX_DOC_ID_TABLE_BYTES = 1073741824;
+var MAX_WORKER_COPIES = 64;
+var VECTOR_SEARCH_TIMEOUT_MS = 3e4;
+var VECTOR_SEARCH_LOAD_TIMEOUT_MS = 3e5;
+var VECTOR_INSERT_TIMEOUT_MS = 6e5;
+var NATIVE_ATTACH_RETRY_MS = 1e3;
+var LOCK_SPIN_ITERATIONS = 128;
+var LOCK_WAIT_SLICE_MS = 20;
+var GRAPH_LOCK_WAIT_SLICE_MS = 1;
+var GRAPH_BUILD_DISPATCH_CHUNK = 64;
+var GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER = 2;
+
+// src/vector/simd-wasm-binary.ts
+var SIMD_DISTANCE_WASM_BASE64 = "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";
+var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
+
+// 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 simdSquaredEuclideanDistance(a, b) {
+  if (!wasmExports || !f32View) return null;
+  ensureMemory(a.length);
+  copyTwoVectors(a, b);
+  return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
+}
+function isSimdAvailable() {
+  return wasmExports !== null;
+}
+var arenaModule;
+function getArenaModule() {
+  if (arenaModule !== void 0) return arenaModule;
+  try {
+    const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
+    const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
+      arenaModule = null;
+      return null;
+    }
+    arenaModule = new WebAssembly.Module(wasmBuffer);
+  } catch {
+    arenaModule = null;
+  }
+  return arenaModule;
+}
+function createArenaSimd() {
+  try {
+    const module = getArenaModule();
+    if (module === null) return null;
+    const instance = new WebAssembly.Instance(module);
+    const exports$1 = instance.exports;
+    if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
+      return null;
+    }
+    return exports$1;
+  } catch {
+    return null;
+  }
+}
+var sharedMemoryModule;
+function getSharedMemoryModule() {
+  if (sharedMemoryModule !== void 0) return sharedMemoryModule;
+  try {
+    const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
+    const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
+      sharedMemoryModule = null;
+      return null;
+    }
+    sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
+  } catch {
+    sharedMemoryModule = null;
+  }
+  return sharedMemoryModule;
+}
+function createSharedArenaSimd(memory) {
+  try {
+    const module = getSharedMemoryModule();
+    if (module === null) return null;
+    const instance = new WebAssembly.Instance(module, { env: { memory } });
+    const exports$1 = instance.exports;
+    if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
+      return null;
+    }
+    return {
+      memory,
+      dot_product: exports$1.dot_product,
+      magnitude: exports$1.magnitude,
+      squared_euclidean_distance: exports$1.squared_euclidean_distance,
+      dot_u8: exports$1.dot_u8,
+      sqdist_u8: exports$1.sqdist_u8,
+      osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
+      osq_dot_bits: exports$1.osq_dot_bits,
+      osq_dot_bits_pair: exports$1.osq_dot_bits_pair
+    };
+  } catch {
+    return null;
+  }
+}
+function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
+  if (metric === "euclidean") {
+    return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
+  }
+  const dot = simd.dot_product(byteA, byteB, dimension);
+  if (metric === "dotProduct") return -dot;
+  if (magnitudeA === 0 || magnitudeB === 0) return 1;
+  return 1 - dot / (magnitudeA * magnitudeB);
+}
+
+// src/vector/native/backend.ts
+var nativeSearchCoreEnabled = true;
+function nativeSearchCoreIsEnabled() {
+  return nativeSearchCoreEnabled;
+}
+function stopUsingTheNativeSearchCore(error) {
+  if (!nativeSearchCoreEnabled) return;
+  nativeSearchCoreEnabled = false;
+  console.warn(
+    "The native search core raised an error, so this thread searches through WebAssembly from now on:",
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function noteFallback(operation) {
+}
+var NATIVE_CORE_ABI_VERSION = 2;
+var BINARY_FILE_NAME = "narsil-core.node";
+var MUSL_DIRECTORY = "musl";
+var PLATFORMS_WITH_A_BINARY = /* @__PURE__ */ new Set([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "win32-arm64",
+  "win32-x64"
+]);
+var loaded;
+function usesMuslLibc() {
+  try {
+    const report = process.report.getReport();
+    return report.header?.glibcVersionRuntime === void 0;
+  } catch {
+    return false;
+  }
+}
+function publishedBinaryPath(require2) {
+  const target = `${process.platform}-${process.arch}`;
+  if (!PLATFORMS_WITH_A_BINARY.has(target)) return null;
+  try {
+    const manifest = require2.resolve(`@delali/narsil-native-${target}/package.json`);
+    const segments = process.platform === "linux" && usesMuslLibc() ? [MUSL_DIRECTORY, BINARY_FILE_NAME] : [BINARY_FILE_NAME];
+    return join(dirname(manifest), ...segments);
+  } catch {
+    return null;
+  }
+}
+function namedBinaryPath() {
+  const named = process.env.NARSIL_NATIVE_CORE_PATH;
+  return named !== void 0 && named.length > 0 ? named : null;
+}
+function refuseToSearchWithoutTheCore(reason) {
+  throw new NarsilError(ErrorCodes.CONFIG_INVALID, `NARSIL_REQUIRE_NATIVE_CORE is 1, and ${reason}`, {
+    platform: `${process.platform}-${process.arch}`
+  });
+}
+function reportMissingCore(reason, named) {
+  if (process.env.NARSIL_REQUIRE_NATIVE_CORE === "1") refuseToSearchWithoutTheCore(reason);
+  if (named) console.warn(`Narsil searches through WebAssembly in this process, because ${reason}.`);
+  return null;
+}
+function loadedCore(path) {
+  const require2 = createRequire(import.meta.url);
+  const core = require2(path);
+  if (typeof core.abiVersion !== "function" || core.abiVersion() !== NATIVE_CORE_ABI_VERSION) return null;
+  return core;
+}
+function loadNativeCore() {
+  if (loaded !== void 0) return loaded;
+  loaded = null;
+  const named = namedBinaryPath();
+  if (process.env.NARSIL_SEARCH_BACKEND === "wasm") {
+    return reportMissingCore("NARSIL_SEARCH_BACKEND asks for the WebAssembly search", false);
+  }
+  const path = named ?? publishedBinaryPath(createRequire(import.meta.url));
+  if (path === null || !existsSync(path)) {
+    return reportMissingCore(`this platform has no native search core at ${path ?? "any known path"}`, named !== null);
+  }
+  try {
+    loaded = loadedCore(path);
+  } catch (error) {
+    return reportMissingCore(
+      `loading the native search core at ${path} failed with "${error instanceof Error ? error.message : String(error)}"`,
+      named !== null
+    );
+  }
+  if (loaded === null) {
+    return reportMissingCore(`the native search core at ${path} reports another ABI version`, named !== null);
+  }
+  return loaded;
+}
+
+// src/vector/shared-buffers/growable.ts
+function sharedMemoryAvailable() {
+  return typeof SharedArrayBuffer === "function";
+}
+function createGrowableBuffer(initialBytes, maxBytes) {
+  const initial = Math.min(initialBytes, maxBytes);
+  if (sharedMemoryAvailable()) {
+    return new SharedArrayBuffer(initial, { maxByteLength: maxBytes });
+  }
+  return new ArrayBuffer(initial, { maxByteLength: maxBytes });
+}
+function createFixedBuffer(bytes) {
+  return sharedMemoryAvailable() ? new SharedArrayBuffer(bytes) : new ArrayBuffer(bytes);
+}
+function nextGrowthTarget(have, needed, max) {
+  return Math.min(max, Math.max(needed, have * 2));
+}
+function growBufferTo(buffer, bytes) {
+  const held = buffer.byteLength;
+  if (held >= bytes) return;
+  resizeBuffer(buffer, bytes, nextGrowthTarget(held, bytes, buffer.maxByteLength));
+}
+function growBufferToExactly(buffer, bytes) {
+  if (buffer.byteLength >= bytes) return;
+  resizeBuffer(buffer, bytes, bytes);
+}
+function resizeBuffer(buffer, bytes, target) {
+  if (bytes > buffer.maxByteLength) {
+    throw new NarsilError(
+      ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
+      `A vector structure needs ${bytes} bytes where it may hold at most ${buffer.maxByteLength}`,
+      { bytes, maxBytes: buffer.maxByteLength }
+    );
+  }
+  if (buffer instanceof ArrayBuffer) {
+    buffer.resize(target);
+    return;
+  }
+  try {
+    buffer.grow(target);
+  } catch (err) {
+    if (buffer.byteLength < bytes) throw err;
+  }
+}
+function fixedView(buffer, kind) {
+  return new kind(buffer, 0, Math.floor(buffer.byteLength / kind.BYTES_PER_ELEMENT));
+}
+
+// src/vector/hnsw/handles.ts
+var GRAPH_ENTRY_POINT = 0;
+var GRAPH_TOP_LAYER = 1;
+var GRAPH_M = 2;
+var GRAPH_MMAX0 = 3;
+var GRAPH_EF_CONSTRUCTION = 4;
+var GRAPH_METRIC = 5;
+var GRAPH_NODE_COUNT = 32;
+var GRAPH_TOMBSTONE_COUNT = 33;
+var GRAPH_UPPER_USED = 64;
+var GRAPH_SLOTS = 65;
+var GRAPH_UPPER_CAPACITY = 66;
+var GRAPH_SLOT_CAPACITY = 67;
+var GRAPH_LOCK = 96;
+var GRAPH_WRITERS_WAITING = 97;
+var GRAPH_ENTRY_LOCK = 128;
+var GRAPH_HEADER_WORDS = 160;
+var HELD_WRITE = 0;
+var HELD_WRITE_VERSION = 1;
+var HELD_GRAPH = 2;
+var HELD_FENCE = 3;
+var HELD_GRAPH_WAITING = 4;
+var HELD_WORDS_PER_THREAD = 32;
+var METRIC_CODES = ["cosine", "dotProduct", "euclidean"];
+function perOrdinal(bytesPerOrdinal, initialOrdinals) {
+  return createGrowableBuffer(initialOrdinals * bytesPerOrdinal, MAX_VECTOR_ORDINALS * bytesPerOrdinal);
+}
+function createSharedGraphHandles(shape) {
+  const header = new Int32Array(createFixedBuffer(GRAPH_HEADER_WORDS * 4), 0, GRAPH_HEADER_WORDS);
+  header[GRAPH_ENTRY_POINT] = -1;
+  header[GRAPH_TOP_LAYER] = -1;
+  header[GRAPH_M] = shape.m;
+  header[GRAPH_MMAX0] = shape.mMax0;
+  header[GRAPH_EF_CONSTRUCTION] = shape.efConstruction;
+  header[GRAPH_METRIC] = Math.max(0, METRIC_CODES.indexOf(shape.metric));
+  const level0Stride = shape.mMax0 + 2;
+  const upperStride = shape.m + 2;
+  const heldWords = VECTOR_SCRATCH_SLOTS * HELD_WORDS_PER_THREAD;
+  const handles = {
+    header,
+    nodeLevels: perOrdinal(1, VECTOR_STORE_INITIAL_CAPACITY),
+    level0: perOrdinal(level0Stride * 4, VECTOR_STORE_INITIAL_CAPACITY),
+    upperBase: perOrdinal(4, VECTOR_STORE_INITIAL_CAPACITY),
+    upper: perOrdinal(upperStride * 4, INITIAL_UPPER_SLOTS),
+    locks: perOrdinal(4, VECTOR_STORE_INITIAL_CAPACITY),
+    tombstones: perOrdinal(1, VECTOR_STORE_INITIAL_CAPACITY),
+    heldLocks: new Int32Array(createFixedBuffer(heldWords * 4), 0, heldWords)
+  };
+  publishGraphCapacity(handles);
+  return handles;
+}
+function raiseHeaderWord(header, word, value) {
+  for (; ; ) {
+    const seen = Atomics.load(header, word);
+    if (seen >= value) return;
+    if (Atomics.compareExchange(header, word, seen, value) === seen) return;
+  }
+}
+function publishGraphCapacity(handles) {
+  const level0Stride = handles.header[GRAPH_MMAX0] + 2;
+  const slotCapacity = Math.min(
+    handles.nodeLevels.byteLength,
+    Math.floor(handles.level0.byteLength / (level0Stride * 4)),
+    Math.floor(handles.upperBase.byteLength / 4),
+    Math.floor(handles.locks.byteLength / 4),
+    handles.tombstones.byteLength
+  );
+  raiseHeaderWord(handles.header, GRAPH_SLOT_CAPACITY, slotCapacity);
+  raiseHeaderWord(handles.header, GRAPH_UPPER_CAPACITY, Math.floor(handles.upper.byteLength / 4));
+}
+function graphShapeOf(header) {
+  return {
+    m: header[GRAPH_M],
+    mMax0: header[GRAPH_MMAX0],
+    efConstruction: header[GRAPH_EF_CONSTRUCTION],
+    metric: METRIC_CODES[header[GRAPH_METRIC]] ?? "cosine"
+  };
+}
+
+// src/vector/vector-store/blocks.ts
+var SCRATCH_ALIGNMENT_BYTES = 16;
+var BLOCK_MAX_BYTES = MAX_WASM_PAGES * WASM_PAGE_BYTES;
+function alignUp(bytes) {
+  return Math.ceil(bytes / SCRATCH_ALIGNMENT_BYTES) * SCRATCH_ALIGNMENT_BYTES;
+}
+function computeVectorBlockLayout(dimension, blockBytes2 = BLOCK_MAX_BYTES) {
+  const scratchStride = alignUp(dimension * 4);
+  const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
+  const slotStride = alignUp(dimension * 4);
+  return {
+    dimension,
+    scratchStride,
+    slotsOffset,
+    slotStride,
+    capacity: Math.max(1, Math.floor((Math.min(blockBytes2, BLOCK_MAX_BYTES) - slotsOffset) / slotStride))
+  };
+}
+function initialBlockBytes(layout) {
+  return layout.slotsOffset + VECTOR_BLOCK_INITIAL_SLOTS * layout.slotStride;
+}
+function pagesFor(bytes) {
+  return Math.ceil(bytes / WASM_PAGE_BYTES);
+}
+function createSharedMemory(pages) {
+  if (!sharedMemoryAvailable() || typeof WebAssembly === "undefined") return null;
+  try {
+    const memory = new WebAssembly.Memory({ initial: pages, maximum: MAX_WASM_PAGES, shared: true });
+    return createSharedArenaSimd(memory) === null ? null : memory;
+  } catch {
+    return null;
+  }
+}
+function createVectorBlock(layout) {
+  const initialBytes = initialBlockBytes(layout);
+  const shared = createSharedMemory(pagesFor(initialBytes));
+  if (shared !== null) return { layout, storage: { kind: "shared-memory", memory: shared } };
+  const simd = createArenaSimd();
+  if (simd !== null) {
+    const missing = pagesFor(initialBytes) - simd.memory.buffer.byteLength / WASM_PAGE_BYTES;
+    if (missing > 0) simd.memory.grow(missing);
+    return { layout, storage: { kind: "private-memory", simd } };
+  }
+  return { layout, storage: { kind: "bytes", buffer: createGrowableBuffer(initialBytes, fullBlockBytes(layout)) } };
+}
+function fullBlockBytes(layout) {
+  return Math.min(BLOCK_MAX_BYTES, layout.slotsOffset + layout.capacity * layout.slotStride);
+}
+function growMemoryTo(memory, bytes, layout) {
+  const have = memory.buffer.byteLength;
+  if (have >= bytes) return;
+  memory.grow(pagesFor(nextGrowthTarget(have, bytes, fullBlockBytes(layout))) - have / WASM_PAGE_BYTES);
+}
+function ensureBlockSlots(handle, slots) {
+  const bytes = handle.layout.slotsOffset + Math.min(slots, handle.layout.capacity) * handle.layout.slotStride;
+  const storage = handle.storage;
+  if (storage.kind === "bytes") {
+    growBufferTo(storage.buffer, bytes);
+    return;
+  }
+  growMemoryTo(storage.kind === "shared-memory" ? storage.memory : storage.simd.memory, bytes, handle.layout);
+}
+function blockBuffer(handle) {
+  const storage = handle.storage;
+  if (storage.kind === "bytes") return storage.buffer;
+  return storage.kind === "shared-memory" ? storage.memory.buffer : storage.simd.memory.buffer;
+}
+var NOTHING_STAGED = -1;
+var QUERY_STAGED = -2;
+function openVectorBlock(handle, threadSlot) {
+  const { layout, storage } = handle;
+  const simd = storage.kind === "shared-memory" ? createSharedArenaSimd(storage.memory) : storage.kind === "private-memory" ? storage.simd : null;
+  const hasScratch = simd !== null && threadSlot >= 0 && threadSlot < VECTOR_SCRATCH_SLOTS;
+  const scratchSlot = hasScratch ? threadSlot : 0;
+  let float32View = fixedView(blockBuffer(handle), Float32Array);
+  let byteView = fixedView(blockBuffer(handle), Uint8Array);
+  let dataView = new DataView(blockBuffer(handle));
+  return {
+    handle,
+    simd,
+    hasScratch,
+    scratchByteOffset: scratchSlot * layout.scratchStride,
+    stagedOrdinal: NOTHING_STAGED,
+    float32(neededLength) {
+      if (neededLength > float32View.length) float32View = fixedView(blockBuffer(handle), Float32Array);
+      return float32View;
+    },
+    bytes(neededLength) {
+      if (neededLength > byteView.length) byteView = fixedView(blockBuffer(handle), Uint8Array);
+      return byteView;
+    },
+    data(neededLength) {
+      if (neededLength > dataView.byteLength) dataView = new DataView(blockBuffer(handle));
+      return dataView;
+    }
+  };
+}
+function slotByteOffset(layout, localOrdinal) {
+  return layout.slotsOffset + localOrdinal * layout.slotStride;
+}
+
+// src/vector/osq/estimate.ts
+var POPCOUNT = new Uint8Array(256);
+for (let value = 0; value < 256; value++) {
+  let count = 0;
+  let rest = value;
+  while (rest !== 0) {
+    count += rest & 1;
+    rest >>= 1;
+  }
+  POPCOUNT[value] = count;
+}
+var LEVEL_BIT_MASK = { 1: 255, 2: 85 };
+var STAGED_QUERY_PLANES = 4;
+function osqNibbleProducts(a, aOffset, b, bOffset, bytes) {
+  let total = 0;
+  for (let n = 0; n < bytes; n++) {
+    const left = a[aOffset + n];
+    const right = b[bOffset + n];
+    total += (left & 15) * (right & 15) + (left >> 4) * (right >> 4);
+  }
+  return total;
+}
+function twoBitStagedProducts(document2, documentOffset, streams, streamsOffset, streamBytes) {
+  let total = 0;
+  for (let n = 0; n < streamBytes; n++) {
+    const packed = document2[documentOffset + n];
+    for (let k = 0; k < STAGED_QUERY_PLANES; k++) {
+      total += (packed >> 2 * k & 3) * streams[streamsOffset + k * streamBytes + n];
+    }
+  }
+  return total;
+}
+function osqStagedQueryProducts(document2, documentOffset, documentBits, staged, stagedOffset, codeBytes) {
+  if (documentBits === 2) return twoBitStagedProducts(document2, documentOffset, staged, stagedOffset, codeBytes);
+  let total = 0;
+  for (let p = 0; p < STAGED_QUERY_PLANES; p++) {
+    const plane = stagedOffset + p * codeBytes;
+    let bitsSet = 0;
+    for (let n = 0; n < codeBytes; n++) bitsSet += POPCOUNT[document2[documentOffset + n] & staged[plane + n]];
+    total += 2 ** p * bitsSet;
+  }
+  return total;
+}
+function osqNarrowPairProducts(a, aOffset, b, bOffset, bits, bytes) {
+  const mask = LEVEL_BIT_MASK[bits];
+  let total = 0;
+  for (let j = 0; j < bits; j++) {
+    for (let l = 0; l < bits; l++) {
+      let bitsSet = 0;
+      for (let n = 0; n < bytes; n++) bitsSet += POPCOUNT[a[aOffset + n] >> j & b[bOffset + n] >> l & mask];
+      total += 2 ** (j + l) * bitsSet;
+    }
+  }
+  return total;
+}
+function osqByteLevelProducts(document2, documentOffset, query, queryOffset, dimension) {
+  let total = 0;
+  for (let i = 0; i < dimension; i++) total += document2[documentOffset + i] * query[queryOffset + i];
+  return total;
+}
+function osqEstimate(products, document2, documentBits, query, queryBits, dimension, centroidDot, metric) {
+  const documentStep = (document2.upper - document2.lower) / OSQ_STEPS[documentBits];
+  const queryStep = (query.upper - query.lower) / OSQ_STEPS[queryBits];
+  const centred = document2.lower * query.lower * dimension + query.lower * documentStep * document2.sum + document2.lower * queryStep * query.sum + documentStep * queryStep * products;
+  if (metric === "euclidean") return Math.sqrt(Math.max(0, document2.correction + query.correction - 2 * centred));
+  const similarity = centred + document2.correction + query.correction - centroidDot;
+  if (metric === "cosine") return Math.min(Math.max(similarity, -1), 1);
+  return similarity;
+}
+function osqDistance(estimate, metric) {
+  switch (metric) {
+    case "cosine":
+      return 1 - estimate;
+    case "dotProduct":
+      return -estimate;
+    case "euclidean":
+      return estimate;
+  }
+}
+function osqQueryBits(bits) {
+  return OSQ_QUERY_BITS[bits];
+}
+
+// src/vector/osq/record.ts
+var OSQ_RECORD_TRAILER_BYTES = 16;
+var TRAILER_LOWER = 0;
+var TRAILER_UPPER = 4;
+var TRAILER_CORRECTION = 8;
+var TRAILER_SUM = 12;
+var QUERY_PLANES_FOR_NARROW_CODES = 4;
+var LEVELS_IN_A_TWO_BIT_BYTE = 4;
+function osqCodeBytes(dimension, bits) {
+  return Math.ceil(dimension * bits / 8);
+}
+function osqRecordBytes(dimension, bits) {
+  return osqCodeBytes(dimension, bits) + OSQ_RECORD_TRAILER_BYTES;
+}
+function packLevels(levels, bits, target, offset) {
+  const dimension = levels.length;
+  if (bits === 8) {
+    target.set(levels, offset);
+    return;
+  }
+  const perByte = 8 / bits;
+  target.fill(0, offset, offset + osqCodeBytes(dimension, bits));
+  for (let i = 0; i < dimension; i++) {
+    const value = levels[i];
+    if (value === 0) continue;
+    target[offset + Math.floor(i / perByte)] |= value << i % perByte * bits;
+  }
+}
+function unpackLevels(bytes, offset, dimension, bits) {
+  const levels = new Uint8Array(dimension);
+  if (bits === 8) {
+    levels.set(bytes.subarray(offset, offset + dimension));
+    return levels;
+  }
+  const perByte = 8 / bits;
+  const mask = (1 << bits) - 1;
+  for (let i = 0; i < dimension; i++) {
+    levels[i] = bytes[offset + Math.floor(i / perByte)] >> i % perByte * bits & mask;
+  }
+  return levels;
+}
+function osqStagedQueryBytes(dimension, documentBits) {
+  if (documentBits === 8) return dimension;
+  if (documentBits === 4) return osqCodeBytes(dimension, 4);
+  return QUERY_PLANES_FOR_NARROW_CODES * osqCodeBytes(dimension, documentBits);
+}
+function stageQueryLevels(levels, documentBits, target) {
+  if (documentBits === 8 || documentBits === 4) {
+    packLevels(levels, documentBits, target, 0);
+    return;
+  }
+  const planeBytes = osqCodeBytes(levels.length, documentBits);
+  target.fill(0, 0, QUERY_PLANES_FOR_NARROW_CODES * planeBytes);
+  if (documentBits === 2) {
+    for (let i = 0; i < levels.length; i++) {
+      target[i % LEVELS_IN_A_TWO_BIT_BYTE * planeBytes + Math.floor(i / LEVELS_IN_A_TWO_BIT_BYTE)] = levels[i];
+    }
+    return;
+  }
+  for (let i = 0; i < levels.length; i++) {
+    const value = levels[i];
+    if (value === 0) continue;
+    const byte = i >> 3;
+    const bit = 1 << (i & 7);
+    for (let plane = 0; plane < QUERY_PLANES_FOR_NARROW_CODES; plane++) {
+      if (value >> plane & 1) target[plane * planeBytes + byte] |= bit;
+    }
+  }
+}
+function writeRecord(target, offset, code, bits, trailer = new DataView(target.buffer, target.byteOffset, target.byteLength)) {
+  packLevels(code.levels, bits, target, offset);
+  const at = offset + osqCodeBytes(code.levels.length, bits);
+  trailer.setFloat32(at + TRAILER_LOWER, code.lower, true);
+  trailer.setFloat32(at + TRAILER_UPPER, code.upper, true);
+  trailer.setFloat32(at + TRAILER_CORRECTION, code.correction, true);
+  trailer.setUint32(at + TRAILER_SUM, code.sum, true);
+}
+function readTrailer(trailer, codeOffset, codeBytes, into) {
+  const at = codeOffset + codeBytes;
+  into.lower = trailer.getFloat32(at + TRAILER_LOWER, true);
+  into.upper = trailer.getFloat32(at + TRAILER_UPPER, true);
+  into.correction = trailer.getFloat32(at + TRAILER_CORRECTION, true);
+  into.sum = trailer.getUint32(at + TRAILER_SUM, true);
+  return into;
+}
+
+// src/vector/vector-store/code-blocks.ts
+function computeCodeBlockLayout(dimension, bits) {
+  const queryBits = osqQueryBits(bits);
+  const codeBytes = osqCodeBytes(dimension, bits);
+  const queryBytes = osqStagedQueryBytes(dimension, bits);
+  const scratchStride = alignUp(queryBytes);
+  const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
+  const slotStride = osqRecordBytes(dimension, bits);
+  return {
+    dimension,
+    bits,
+    queryBits,
+    codeBytes,
+    queryBytes,
+    scratchStride,
+    slotsOffset,
+    slotStride,
+    capacity: Math.floor((BLOCK_MAX_BYTES - slotsOffset) / slotStride)
+  };
+}
+
+// src/vector/vector-store/handles.ts
+var STORE_SLOTS = 0;
+var STORE_LIVE_COUNT = 1;
+var STORE_BLOCK_COUNT = 2;
+var STORE_CALIBRATED = 3;
+var STORE_CODE_COUNT = 4;
+var STORE_DOC_ID_BYTES = 5;
+var STORE_CODE_BLOCK_COUNT = 6;
+var STORE_CALIBRATION_GENERATION = 7;
+var STORE_RELEASED_VECTORS_TO_DISK = 8;
+var STORE_HEADER_WORDS = 16;
+var IN_MEMORY = -1;
+function fixedInt32(words) {
+  return new Int32Array(createFixedBuffer(words * 4), 0, words);
+}
+function fixedFloat32(length) {
+  return new Float32Array(createFixedBuffer(length * 4), 0, length);
+}
+function perOrdinal2(bytesPerOrdinal) {
+  return createGrowableBuffer(
+    VECTOR_STORE_INITIAL_CAPACITY * bytesPerOrdinal,
+    (MAX_VECTOR_ORDINALS + 1) * bytesPerOrdinal
+  );
+}
+function inMemoryTable() {
+  const buffer = perOrdinal2(4);
+  new Int32Array(buffer).fill(IN_MEMORY);
+  return buffer;
+}
+function createSharedVectorStoreHandles(dimension, codeBits, blockBytes2 = BLOCK_MAX_BYTES) {
+  return {
+    dimension,
+    codeBits,
+    layout: computeVectorBlockLayout(dimension, blockBytes2),
+    codeLayout: codeBits === null ? null : computeCodeBlockLayout(dimension, codeBits),
+    layoutRevision: 0,
+    header: fixedInt32(STORE_HEADER_WORDS),
+    blocks: [],
+    codeBlocks: [],
+    vectorFiles: [],
+    magnitudes: perOrdinal2(8),
+    present: perOrdinal2(1),
+    partitions: perOrdinal2(4),
+    docIdBytes: createGrowableBuffer(VECTOR_STORE_INITIAL_CAPACITY * 16, MAX_DOC_ID_TABLE_BYTES),
+    docIdOffsets: perOrdinal2(4),
+    codePresent: perOrdinal2(1),
+    diskFile: inMemoryTable(),
+    diskOffset: perOrdinal2(4),
+    centroid: fixedFloat32(dimension)
+  };
+}
+function sharedVectorStoreBytes(handles) {
+  let bytes = handles.header.byteLength + handles.centroid.byteLength;
+  for (const block of handles.blocks) {
+    if (block !== null) bytes += blockBuffer(block).byteLength;
+  }
+  for (const block of handles.codeBlocks) bytes += blockBuffer(block).byteLength;
+  bytes += handles.magnitudes.byteLength;
+  bytes += handles.present.byteLength;
+  bytes += handles.partitions.byteLength;
+  bytes += handles.docIdBytes.byteLength;
+  bytes += handles.docIdOffsets.byteLength;
+  bytes += handles.codePresent.byteLength;
+  bytes += handles.diskFile.byteLength;
+  bytes += handles.diskOffset.byteLength;
+  return bytes;
+}
+
+// src/vector/native/types.ts
+var NATIVE_OK = 0;
+var NATIVE_NEEDS_ROOM = 3;
+
+// src/vector/native/store.ts
+var METRIC_CODES2 = { cosine: 0, dotProduct: 1, euclidean: 2 };
+var attachedStores = /* @__PURE__ */ new WeakMap();
+function nativeMetricCode(metric) {
+  return METRIC_CODES2[metric];
+}
+function isSharedMemory(buffer) {
+  return typeof SharedArrayBuffer === "function" && buffer instanceof SharedArrayBuffer;
+}
+function blockBytes(block) {
+  const storage = block.storage;
+  if (storage.kind === "shared-memory") return new Uint8Array(storage.memory.buffer, block.layout.slotsOffset);
+  if (storage.kind === "bytes" && isSharedMemory(storage.buffer)) {
+    return new Uint8Array(storage.buffer, block.layout.slotsOffset);
+  }
+  return null;
+}
+function storeMemory(store) {
+  const regions = [
+    store.header.buffer,
+    store.codePresent,
+    store.centroid.buffer,
+    store.magnitudes,
+    store.present,
+    store.diskFile,
+    store.diskOffset
+  ];
+  if (!regions.every(isSharedMemory)) return null;
+  const codeBlocks = [];
+  for (const block of store.codeBlocks) {
+    const bytes = blockBytes(block);
+    if (bytes === null) return null;
+    codeBlocks.push(bytes);
+  }
+  const vectorBlocks = [];
+  for (const block of store.blocks) {
+    const bytes = block === null ? null : blockBytes(block);
+    if (block !== null && bytes === null) return null;
+    vectorBlocks.push(bytes);
+  }
+  return {
+    storeHeader: store.header,
+    dimension: store.dimension,
+    bits: store.codeBits ?? 0,
+    recordsPerBlock: store.codeLayout?.capacity ?? 0,
+    vectorsPerBlock: store.layout.capacity,
+    vectorStrideBytes: store.layout.slotStride,
+    codePresent: fixedView(store.codePresent, Uint8Array),
+    centroid: store.centroid,
+    magnitudes: fixedView(store.magnitudes, Float64Array),
+    present: fixedView(store.present, Uint8Array),
+    vectorFile: fixedView(store.diskFile, Int32Array),
+    vectorOffset: fixedView(store.diskOffset, Uint32Array),
+    vectorFiles: [...store.vectorFiles],
+    codeBlocks,
+    vectorBlocks
+  };
+}
+function attach(core, store) {
+  const memory = storeMemory(store);
+  let handle = null;
+  if (memory !== null) {
+    try {
+      handle = core.attachStore(memory);
+    } catch {
+      handle = null;
+    }
+  }
+  return {
+    core,
+    handle,
+    layoutRevision: store.layoutRevision,
+    vectorBlockCount: store.blocks.length,
+    codeBlockCount: store.codeBlocks.length,
+    retryAt: handle === null ? Date.now() + NATIVE_ATTACH_RETRY_MS : Number.POSITIVE_INFINITY,
+    ordinals: new Int32Array(0),
+    distances: new Float64Array(0)
+  };
+}
+function stillCurrent(attached, store) {
+  return Date.now() < attached.retryAt && attached.layoutRevision === store.layoutRevision && attached.vectorBlockCount === store.blocks.length && attached.codeBlockCount === store.codeBlocks.length;
+}
+function isUsable(attached) {
+  return attached.handle !== null;
+}
+function detachNativeStore(store) {
+  const attached = attachedStores.get(store);
+  if (attached === void 0) return;
+  attachedStores.delete(store);
+  if (attached.handle === null) return;
+  try {
+    attached.core.detachStore(attached.handle);
+  } catch (error) {
+    stopUsingTheNativeSearchCore(error);
+  }
+}
+function attachedNativeStore(store) {
+  const attached = attachedStores.get(store);
+  return attached !== void 0 && isUsable(attached) ? attached : null;
+}
+function nativeStoreScratchBytes(store) {
+  const attached = attachedNativeStore(store);
+  return attached === null ? 0 : attached.ordinals.byteLength + attached.distances.byteLength;
+}
+function nativeStoreFor(store) {
+  if (!nativeSearchCoreIsEnabled()) return null;
+  const core = loadNativeCore();
+  if (core === null) return null;
+  let attached = attachedStores.get(store);
+  if (attached !== void 0 && !stillCurrent(attached, store)) {
+    detachNativeStore(store);
+    attached = void 0;
+  }
+  if (attached === void 0) {
+    attached = attach(core, store);
+    attachedStores.set(store, attached);
+  }
+  return isUsable(attached) ? attached : null;
+}
+function reserveOrdinals(store, count) {
+  if (store.ordinals.length >= count) return;
+  store.ordinals = new Int32Array(count);
+  store.distances = new Float64Array(count);
+}
+function nativeScores(store, query, metric, count) {
+  if (count === 0) return store.distances;
+  let status;
+  try {
+    status = store.core.score(store.handle, query, nativeMetricCode(metric), store.ordinals, count, store.distances);
+  } catch (error) {
+    stopUsingTheNativeSearchCore(error);
+    return null;
+  }
+  return status === NATIVE_OK ? store.distances : null;
+}
+function nativeScoresOf(handles, query, metric, ordinals) {
+  const store = nativeStoreFor(handles);
+  if (store === null) return null;
+  reserveOrdinals(store, ordinals.length);
+  store.ordinals.set(ordinals);
+  return nativeScores(store, query, metric, ordinals.length);
+}
+function workOnRecords(handles, metric, ordinals, work) {
+  if (ordinals.length === 0) return true;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const store = nativeStoreFor(handles);
+    if (store === null) return false;
+    let status;
+    try {
+      status = store.core[work](store.handle, nativeMetricCode(metric), ordinals, ordinals.length);
+    } catch (error) {
+      stopUsingTheNativeSearchCore(error);
+      return false;
+    }
+    if (status === NATIVE_OK) return true;
+    if (status !== NATIVE_NEEDS_ROOM) return false;
+    detachNativeStore(handles);
+  }
+  return false;
+}
+function nativeCalibrate(handles, metric, ordinals) {
+  return workOnRecords(handles, metric, ordinals, "calibrate");
+}
+function nativeQuantise(handles, metric, ordinals) {
+  if (Atomics.load(handles.header, STORE_CALIBRATED) !== 1) return false;
+  return workOnRecords(handles, metric, ordinals, "quantise");
+}
+
+// src/vector/native/field.ts
+var WAKE_COUNT_WORDS = 1;
+var WAKES_THE_CORE_KEEPS_PER_CALL = 256;
+var WAKE_LIST_WORDS = WAKE_COUNT_WORDS + WAKES_THE_CORE_KEEPS_PER_CALL;
+var WAKE_ENTRY_LOCK = -1;
+var attachedGraphs = /* @__PURE__ */ new WeakMap();
+function graphMemory(graph) {
+  const regions = [
+    graph.header.buffer,
+    graph.nodeLevels,
+    graph.level0,
+    graph.upperBase,
+    graph.upper,
+    graph.locks,
+    graph.tombstones,
+    graph.heldLocks.buffer
+  ];
+  if (!regions.every(isSharedMemory)) return null;
+  return {
+    graphHeader: graph.header,
+    nodeLevels: fixedView(graph.nodeLevels, Uint8Array),
+    level0: fixedView(graph.level0, Int32Array),
+    upperBase: fixedView(graph.upperBase, Int32Array),
+    upper: fixedView(graph.upper, Int32Array),
+    locks: fixedView(graph.locks, Int32Array),
+    tombstones: fixedView(graph.tombstones, Uint8Array),
+    heldLocks: graph.heldLocks
+  };
+}
+function attach2(core, state) {
+  const memory = graphMemory(state.adjacency.handles);
+  let handle = null;
+  if (memory !== null) {
+    try {
+      handle = core.attachGraph(memory);
+    } catch {
+      handle = null;
+    }
+  }
+  return { handle, field: null };
+}
+var workspaceOwner = null;
+function nativeScratchBytes(state, field) {
+  const perField = field.store.ordinals.byteLength + field.store.distances.byteLength + field.wakes.byteLength;
+  const owner = workspaceOwner?.deref();
+  if (owner !== void 0 && owner !== state) return perField;
+  workspaceOwner = new WeakRef(state);
+  return perField + field.core.workspaceBytes();
+}
+function attachedNativeField(state) {
+  if (!nativeSearchCoreIsEnabled()) return null;
+  return attachedGraphs.get(state)?.field ?? null;
+}
+function nativeFieldFor(state) {
+  if (!nativeSearchCoreIsEnabled()) return null;
+  const core = loadNativeCore();
+  if (core === null) return null;
+  const store = nativeStoreFor(state.store.handles);
+  if (store === null) return null;
+  let attached = attachedGraphs.get(state);
+  if (attached === void 0) {
+    attached = attach2(core, state);
+    attachedGraphs.set(state, attached);
+  }
+  if (attached.handle === null) return null;
+  if (attached.field === null) {
+    attached.field = { core, graph: attached.handle, store, wakes: new Int32Array(WAKE_LIST_WORDS) };
+  }
+  attached.field.store = store;
+  return attached.field;
+}
+function wakeSleepingThreads(state, field) {
+  const count = field.wakes[0];
+  if (count === 0) return;
+  field.wakes[0] = 0;
+  for (let i = 1; i <= count; i++) {
+    const ordinal = field.wakes[i];
+    if (ordinal === WAKE_ENTRY_LOCK) {
+      Atomics.notify(state.header, GRAPH_ENTRY_LOCK);
+      continue;
+    }
+    if (ordinal < 0 || ordinal >= Atomics.load(state.header, GRAPH_SLOTS)) continue;
+    Atomics.notify(state.locks.words(ordinal), ordinal);
+  }
+}
+
+// src/vector/native/writes.ts
+var CALL_RAISED = -1;
+function writeToTheGraph(state, field, write) {
+  let status;
+  try {
+    status = write();
+  } catch (error) {
+    stopUsingTheNativeSearchCore(error);
+    return CALL_RAISED;
+  }
+  wakeSleepingThreads(state, field);
+  return status;
+}
+function nativePlace(state, field, metric, ordinal, topLayer, graphHeldAlone) {
+  const status = writeToTheGraph(
+    state,
+    field,
+    () => field.core.place(
+      field.graph,
+      field.store.handle,
+      nativeMetricCode(metric),
+      ordinal,
+      topLayer,
+      graphHeldAlone ? 1 : 0,
+      state.locks.threadSlot,
+      field.wakes
+    )
+  );
+  if (status === NATIVE_OK) return "placed";
+  return status === NATIVE_NEEDS_ROOM ? "needsRoom" : "failed";
+}
+function nativeRemove(state, field, ordinal) {
+  const remove = () => field.core.remove(field.graph, ordinal, state.locks.threadSlot, field.wakes);
+  return writeToTheGraph(state, field, remove) === NATIVE_OK;
+}
+function nativeCompact(state, field, metric) {
+  const compact = () => field.core.compact(field.graph, field.store.handle, nativeMetricCode(metric), state.locks.threadSlot, field.wakes);
+  return writeToTheGraph(state, field, compact) === NATIVE_OK;
+}
+
+// src/vector/hnsw/adjacency/views.ts
+var ABSENT = -1;
+function openAdjacency(handles, m, mMax0) {
+  return {
+    m,
+    mMax0,
+    level0Stride: mMax0 + 2,
+    upperStride: m + 2,
+    handles,
+    header: handles.header,
+    nodeLevels: fixedView(handles.nodeLevels, Uint8Array),
+    level0: fixedView(handles.level0, Int32Array),
+    upperBase: fixedView(handles.upperBase, Int32Array),
+    upper: fixedView(handles.upper, Int32Array)
+  };
+}
+function rebindNodes(adj) {
+  adj.nodeLevels = fixedView(adj.handles.nodeLevels, Uint8Array);
+  adj.level0 = fixedView(adj.handles.level0, Int32Array);
+  adj.upperBase = fixedView(adj.handles.upperBase, Int32Array);
+}
+function rebindUpper(adj) {
+  adj.upper = fixedView(adj.handles.upper, Int32Array);
+}
+function reachNode(adj, ord) {
+  if (ord < adj.nodeLevels.length) return true;
+  if (ord >= adj.handles.nodeLevels.byteLength) return false;
+  rebindNodes(adj);
+  return ord < adj.nodeLevels.length;
+}
+function reachUpper(adj, end) {
+  if (end <= adj.upper.length) return true;
+  if (end * 4 > adj.handles.upper.byteLength) return false;
+  rebindUpper(adj);
+  return end <= adj.upper.length;
+}
+function adjacencySlots(adj) {
+  return Atomics.load(adj.header, GRAPH_SLOTS);
+}
+function upperUsed(adj) {
+  return Atomics.load(adj.header, GRAPH_UPPER_USED);
+}
+function ensureAdjacencyCapacity(adj, needed) {
+  if (needed <= adj.nodeLevels.length) return;
+  const { handles } = adj;
+  if (needed <= handles.nodeLevels.byteLength) {
+    rebindNodes(adj);
+    return;
+  }
+  const capacity = Math.max(needed, Math.min(handles.nodeLevels.byteLength * 2, handles.nodeLevels.maxByteLength));
+  growBufferToExactly(handles.level0, capacity * adj.level0Stride * 4);
+  growBufferToExactly(handles.upperBase, capacity * 4);
+  growBufferToExactly(handles.locks, capacity * 4);
+  growBufferToExactly(handles.tombstones, capacity);
+  growBufferToExactly(handles.nodeLevels, capacity);
+  publishGraphCapacity(handles);
+  rebindNodes(adj);
+}
+function growUpperTo(adj, entries) {
+  const held = adj.handles.upper.byteLength;
+  growBufferTo(adj.handles.upper, entries * 4);
+  if (adj.handles.upper.byteLength !== held) publishGraphCapacity(adj.handles);
+}
+function ensureUpperCapacity(adj, entries) {
+  growUpperTo(adj, entries);
+  rebindUpper(adj);
+}
+function ensureUpperRoom(adj, levels) {
+  if (levels < 1) return;
+  growUpperTo(adj, Atomics.load(adj.header, GRAPH_UPPER_USED) + levels * adj.upperStride);
+}
+function allocateUpperBlock(adj, levels) {
+  const size = levels * adj.upperStride;
+  for (; ; ) {
+    const offset = Atomics.load(adj.header, GRAPH_UPPER_USED);
+    growUpperTo(adj, offset + size);
+    if (Atomics.compareExchange(adj.header, GRAPH_UPPER_USED, offset, offset + size) !== offset) continue;
+    rebindUpper(adj);
+    return offset;
+  }
+}
+function raiseSlots(adj, slots) {
+  for (; ; ) {
+    const seen = Atomics.load(adj.header, GRAPH_SLOTS);
+    if (seen >= slots) return;
+    if (Atomics.compareExchange(adj.header, GRAPH_SLOTS, seen, slots) === seen) return;
+  }
+}
+function createNode(adj, ord, maxLayer) {
+  ensureAdjacencyCapacity(adj, ord + 1);
+  adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) + 1 : 0;
+  adj.level0[ord * adj.level0Stride] = 0;
+  raiseSlots(adj, ord + 1);
+  Atomics.store(adj.nodeLevels, ord, maxLayer + 1);
+}
+function deleteNode(adj, ord) {
+  if (ord < 0 || !reachNode(adj, ord)) return;
+  Atomics.store(adj.nodeLevels, ord, 0);
+  adj.upperBase[ord] = 0;
+  adj.level0[ord * adj.level0Stride] = 0;
+}
+function resetAdjacency(adj) {
+  rebindNodes(adj);
+  rebindUpper(adj);
+  adj.nodeLevels.fill(0);
+  adj.level0.fill(0);
+  adj.upperBase.fill(0);
+  adj.upper.fill(0);
+  Atomics.store(adj.header, GRAPH_UPPER_USED, 0);
+  Atomics.store(adj.header, GRAPH_SLOTS, 0);
+}
+function nodeLevel(adj, ord) {
+  if (ord < 0 || !reachNode(adj, ord)) return ABSENT;
+  return adj.nodeLevels[ord] - 1;
+}
+function hasNode(adj, ord) {
+  return nodeLevel(adj, ord) !== ABSENT;
+}
+function graphBytes(adj) {
+  const handles = adj.handles;
+  return handles.header.byteLength + handles.nodeLevels.byteLength + handles.level0.byteLength + handles.upperBase.byteLength + handles.upper.byteLength + handles.locks.byteLength + handles.tombstones.byteLength + handles.heldLocks.byteLength;
+}
+
+// src/vector/hnsw/adjacency/neighbors.ts
+function layerArray(adj, layer) {
+  return layer === 0 ? adj.level0 : adj.upper;
+}
+function layerBase(adj, ord, layer) {
+  const level2 = nodeLevel(adj, ord);
+  if (level2 === ABSENT || layer > level2) return ABSENT;
+  if (layer === 0) return ord * adj.level0Stride;
+  const base = adj.upperBase[ord];
+  if (base === 0) return ABSENT;
+  const start = base - 1 + (layer - 1) * adj.upperStride;
+  return reachUpper(adj, start + adj.upperStride) ? start : ABSENT;
+}
+function neighborCount(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return 0;
+  return layerArray(adj, layer)[base];
+}
+function readNeighbors(adj, ord, layer, out) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return 0;
+  const array = layerArray(adj, layer);
+  const count = Math.min(array[base], out.length);
+  for (let i = 0; i < count; i++) out[i] = array[base + i + 1];
+  return count;
+}
+function collectNeighbors(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return [];
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  const collected = new Array(count);
+  for (let i = 0; i < count; i++) collected[i] = array[base + i + 1];
+  return collected;
+}
+function addNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] === neighborOrd) return;
+  }
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  if (count + 1 > stride - 1) return;
+  array[base + count + 1] = neighborOrd;
+  array[base] = count + 1;
+}
+function removeNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] !== neighborOrd) continue;
+    for (let j = i; j < count; j++) {
+      array[base + j] = array[base + j + 1];
+    }
+    array[base] = count - 1;
+    return;
+  }
+}
+function replaceNeighbors(adj, ord, layer, neighbors, count) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  const limit = Math.min(count, stride - 1);
+  for (let i = 0; i < limit; i++) {
+    array[base + i + 1] = neighbors[i];
+  }
+  array[base] = limit;
+}
+
+// src/vector/hnsw/locks.ts
+var FREE = 0;
+var EXCLUSIVE = -1;
+function openGraphLocks(handles, threadSlot) {
+  let words = fixedView(handles.locks, Int32Array);
+  return {
+    threadSlot,
+    header: handles.header,
+    held: handles.heldLocks,
+    words(ord) {
+      if (ord < words.length) return words;
+      if (ord * 4 >= handles.locks.byteLength) growBufferTo(handles.locks, (ord + 1) * 4);
+      words = fixedView(handles.locks, Int32Array);
+      return words;
+    }
+  };
+}
+var blockingAllowed = typeof document === "undefined";
+function canWait(words) {
+  return blockingAllowed && sharedMemoryAvailable() && words.buffer instanceof SharedArrayBuffer;
+}
+function waitOn(words, index, seen, sliceMs = LOCK_WAIT_SLICE_MS) {
+  if (!canWait(words)) return;
+  Atomics.wait(words, index, seen, sliceMs);
+}
+function heldIndex(locks, kind) {
+  return locks.threadSlot * HELD_WORDS_PER_THREAD + kind;
+}
+function acquireExclusive(words, index) {
+  let spins = 0;
+  for (; ; ) {
+    const seen = Atomics.compareExchange(words, index, FREE, EXCLUSIVE);
+    if (seen === FREE) return;
+    if (spins < LOCK_SPIN_ITERATIONS) {
+      spins += 1;
+      continue;
+    }
+    waitOn(words, index, seen, GRAPH_LOCK_WAIT_SLICE_MS);
+  }
+}
+function releaseExclusive(words, index) {
+  Atomics.store(words, index, FREE);
+  if (canWait(words)) Atomics.notify(words, index);
+}
+var WRITE_HELD = 1;
+var WRITER_WAITING = 2;
+var VERSION_STEP = 4;
+function beginNodeRead(locks, ord) {
+  const words = locks.words(ord);
+  for (; ; ) {
+    const seen = Atomics.load(words, ord);
+    if ((seen & WRITE_HELD) === 0) return seen;
+  }
+}
+function nodeReadHeld(locks, ord, version) {
+  Atomics.add(locks.held, heldIndex(locks, HELD_FENCE), 0);
+  return Atomics.load(locks.words(ord), ord) === version;
+}
+function lockNodeWrite(locks, ord) {
+  const words = locks.words(ord);
+  let spins = 0;
+  for (; ; ) {
+    const seen = Atomics.load(words, ord);
+    if ((seen & WRITE_HELD) === 0) {
+      const claimed = seen | WRITE_HELD;
+      if (Atomics.compareExchange(words, ord, seen, claimed) === seen) {
+        Atomics.store(locks.held, heldIndex(locks, HELD_WRITE_VERSION), claimed);
+        Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), ord + 1);
+        return;
+      }
+      continue;
+    }
+    if (spins < LOCK_SPIN_ITERATIONS) {
+      spins += 1;
+      continue;
+    }
+    const waiting = seen | WRITER_WAITING;
+    if (waiting === seen || Atomics.compareExchange(words, ord, seen, waiting) === seen) {
+      waitOn(words, ord, waiting);
+    }
+  }
+}
+function releaseWrite(words, ord) {
+  const seen = Atomics.load(words, ord);
+  const previous = Atomics.exchange(words, ord, (seen & -4) + VERSION_STEP);
+  if ((previous & WRITER_WAITING) !== 0 && canWait(words)) Atomics.notify(words, ord);
+}
+function unlockNodeWrite(locks, ord) {
+  releaseWrite(locks.words(ord), ord);
+  Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), 0);
+}
+function lockGraphShared(locks) {
+  const { header } = locks;
+  let spins = 0;
+  for (; ; ) {
+    const seen = Atomics.load(header, GRAPH_LOCK);
+    if (seen >= FREE && Atomics.load(header, GRAPH_WRITERS_WAITING) === 0) {
+      if (Atomics.compareExchange(header, GRAPH_LOCK, seen, seen + 1) === seen) {
+        Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 1);
+        return;
+      }
+      continue;
+    }
+    if (spins < LOCK_SPIN_ITERATIONS) {
+      spins += 1;
+      continue;
+    }
+    waitOn(header, GRAPH_LOCK, seen, GRAPH_LOCK_WAIT_SLICE_MS);
+  }
+}
+function unlockGraphShared(locks) {
+  const { header } = locks;
+  Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 0);
+  if (Atomics.sub(header, GRAPH_LOCK, 1) === 1 && canWait(header)) Atomics.notify(header, GRAPH_LOCK);
+}
+function lockGraphExclusive(locks) {
+  Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 1);
+  Atomics.add(locks.header, GRAPH_WRITERS_WAITING, 1);
+  try {
+    acquireExclusive(locks.header, GRAPH_LOCK);
+  } finally {
+    Atomics.sub(locks.header, GRAPH_WRITERS_WAITING, 1);
+    Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 0);
+  }
+}
+function unlockGraphExclusive(locks) {
+  releaseExclusive(locks.header, GRAPH_LOCK);
+}
+function lockEntry(locks) {
+  acquireExclusive(locks.header, GRAPH_ENTRY_LOCK);
+}
+function unlockEntry(locks) {
+  releaseExclusive(locks.header, GRAPH_ENTRY_LOCK);
+}
+function releaseLocksHeldBy(handles, threadSlot) {
+  const held = handles.heldLocks;
+  const words = new Int32Array(handles.locks);
+  const base = threadSlot * HELD_WORDS_PER_THREAD;
+  if (Atomics.exchange(held, base + HELD_GRAPH_WAITING, 0) === 1) {
+    Atomics.sub(handles.header, GRAPH_WRITERS_WAITING, 1);
+  }
+  const writeOrd = Atomics.exchange(held, base + HELD_WRITE, 0) - 1;
+  const writeVersion = Atomics.load(held, base + HELD_WRITE_VERSION);
+  if (writeOrd >= 0 && writeOrd < words.length) {
+    const seen = Atomics.load(words, writeOrd);
+    if ((seen & ~WRITER_WAITING) === writeVersion) releaseWrite(words, writeOrd);
+  }
+  if (Atomics.exchange(held, base + HELD_GRAPH, 0) !== 1) return;
+  for (; ; ) {
+    const readers = Atomics.load(handles.header, GRAPH_LOCK);
+    if (readers <= FREE) return;
+    if (Atomics.compareExchange(handles.header, GRAPH_LOCK, readers, readers - 1) === readers) {
+      if (canWait(handles.header)) Atomics.notify(handles.header, GRAPH_LOCK);
+      return;
+    }
+  }
+}
+
+// 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) {
+  return Math.sqrt(squaredEuclideanDistance(a, b));
+}
+function squaredEuclideanDistance(a, b) {
+  const result = simdSquaredEuclideanDistance(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 sum;
+}
+
+// src/vector/hnsw/shared.ts
+function entryPointOf(state) {
+  return Atomics.load(state.header, GRAPH_ENTRY_POINT);
+}
+function topLayerOf(state) {
+  return Atomics.load(state.header, GRAPH_TOP_LAYER);
+}
+function nodeCountOf(state) {
+  return Atomics.load(state.header, GRAPH_NODE_COUNT);
+}
+function tombstoneCountOf(state) {
+  return Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT);
+}
+function ensureCapacity(state, needed) {
+  ensureAdjacencyCapacity(state.adjacency, needed);
+  ensureVisited(state, needed);
+}
+function ensureVisited(state, needed) {
+  if (needed <= state.visited.length) return;
+  let capacity = state.visited.length === 0 ? 16 : state.visited.length;
+  while (capacity < needed) capacity *= 2;
+  const next = new Uint32Array(capacity);
+  next.set(state.visited);
+  state.visited = next;
+}
+function nextVisitStamp(state) {
+  state.visitStamp++;
+  if (state.visitStamp === 4294967295) {
+    state.visited.fill(0);
+    state.visitStamp = 1;
+  }
+  return state.visitStamp;
+}
+function reachTombstone(state, ord) {
+  if (ord < state.tombstones.length) return true;
+  if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
+  state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
+  return ord < state.tombstones.length;
+}
+function isTombstoned(state, ord) {
+  return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
+}
+function nodeExists(state, ord) {
+  return hasNode(state.adjacency, ord);
+}
+function nodeMaxLayer(state, ord) {
+  return nodeLevel(state.adjacency, ord);
+}
+function toDistance(a, b, magA, magB, metric) {
+  switch (metric) {
+    case "cosine":
+      return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
+    case "dotProduct":
+      return -dotProduct(a, b);
+    case "euclidean":
+      return euclideanDistance(a, b);
+  }
+}
+function toScore(distance, metric) {
+  switch (metric) {
+    case "cosine":
+      return 1 - distance;
+    case "dotProduct":
+      return -distance;
+    case "euclidean":
+      return 1 / (1 + distance);
+  }
+}
+function randomLevel(mL) {
+  let u = Math.random();
+  if (u === 0) u = Number.MIN_VALUE;
+  return Math.min(Math.floor(-Math.log(u) * mL), MAX_LAYER_CAP);
+}
+function entryForOrd(state, ord) {
+  return state.store.entryForOrdinal(ord);
+}
+function buildsFromCodes(state) {
+  return activeQuantizer(state) !== void 0;
+}
+function activeQuantizer(state) {
+  const quantizer = state.quantizer;
+  if (quantizer === void 0 || !quantizer.isCalibrated()) return void 0;
+  return quantizer;
+}
+function nodeDistanceByOrd(state, aOrd, bOrd, metric) {
+  if (buildsFromCodes(state) && state.quantizer !== void 0) {
+    const estimated = state.quantizer.distanceBetweenOrdinals(aOrd, bOrd);
+    if (estimated !== Number.POSITIVE_INFINITY) return estimated;
+  }
+  return state.store.distanceByOrdinal(aOrd, bOrd, metric);
+}
+function nodeDistanceFunction(state, metric) {
+  const storeDistance = state.store.pairDistance(metric);
+  const quantizer = state.quantizer;
+  if (quantizer === void 0) return storeDistance;
+  const codeDistance = quantizer.pairDistance();
+  return (aOrd, bOrd) => {
+    if (buildsFromCodes(state)) {
+      const estimated = codeDistance(aOrd, bOrd);
+      if (estimated !== Number.POSITIVE_INFINITY) return estimated;
+    }
+    return storeDistance(aOrd, bOrd);
+  };
+}
+function queryDistanceByOrd(state, qVec, qMag, ord, metric) {
+  const entry = state.store.entryForOrdinal(ord);
+  if (!entry) return Number.POSITIVE_INFINITY;
+  return toDistance(qVec, entry.vector, qMag, entry.magnitude, metric);
+}
+function maxConns(state, layer) {
+  return layer === 0 ? state.Mmax0 : state.M;
+}
+function addConnection(connections, ord) {
+  for (let i = 0; i < connections.length; i++) {
+    if (connections[i] === ord) return;
+  }
+  connections.push(ord);
+}
+
+// src/vector/hnsw/workspace.ts
+function createList(capacity) {
+  return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
+}
+function createHeap(greatestFirst) {
+  return { ...createList(INITIAL_LIST_CAPACITY), greatestFirst, topOrd: -1, topDistance: 0 };
+}
+function createHNSWWorkspace() {
+  return {
+    frontier: createHeap(false),
+    found: createHeap(true),
+    entryPoints: new Int32Array(INITIAL_LIST_CAPACITY),
+    entryPointCount: 0,
+    traversal: createList(INITIAL_LIST_CAPACITY),
+    working: createList(INITIAL_LIST_CAPACITY),
+    linkSelections: [],
+    pruneCandidates: createList(INITIAL_LIST_CAPACITY),
+    pruneSelection: createList(INITIAL_LIST_CAPACITY),
+    repairCandidates: createList(INITIAL_LIST_CAPACITY),
+    repairSelection: createList(INITIAL_LIST_CAPACITY)
+  };
+}
+function linkSelectionsFor(workspace, layers) {
+  const selections = workspace.linkSelections;
+  while (selections.length < layers) selections.push(createList(INITIAL_LIST_CAPACITY));
+  return selections;
+}
+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 siftUpGreatestFirst(ords, distances, start, ord, distance) {
+  let index = start;
+  while (index > 0) {
+    const parent = index - 1 >> 1;
+    if (!(distance > distances[parent])) break;
+    ords[index] = ords[parent];
+    distances[index] = distances[parent];
+    index = parent;
+  }
+  ords[index] = ord;
+  distances[index] = distance;
+}
+function siftUpLeastFirst(ords, distances, start, ord, distance) {
+  let index = start;
+  while (index > 0) {
+    const parent = index - 1 >> 1;
+    if (!(distance < distances[parent])) break;
+    ords[index] = ords[parent];
+    distances[index] = distances[parent];
+    index = parent;
+  }
+  ords[index] = ord;
+  distances[index] = distance;
+}
+function siftDownGreatestFirst(ords, distances, size, ord, distance) {
+  let index = 0;
+  for (; ; ) {
+    const left = 2 * index + 1;
+    const right = left + 1;
+    let first = index;
+    let firstDistance = distance;
+    if (left < size && distances[left] > firstDistance) {
+      first = left;
+      firstDistance = distances[left];
+    }
+    if (right < size && distances[right] > firstDistance) first = right;
+    if (first === index) break;
+    ords[index] = ords[first];
+    distances[index] = distances[first];
+    index = first;
+  }
+  ords[index] = ord;
+  distances[index] = distance;
+}
+function siftDownLeastFirst(ords, distances, size, ord, distance) {
+  let index = 0;
+  for (; ; ) {
+    const left = 2 * index + 1;
+    const right = left + 1;
+    let first = index;
+    let firstDistance = distance;
+    if (left < size && distances[left] < firstDistance) {
+      first = left;
+      firstDistance = distances[left];
+    }
+    if (right < size && distances[right] < firstDistance) first = right;
+    if (first === index) break;
+    ords[index] = ords[first];
+    distances[index] = distances[first];
+    index = first;
+  }
+  ords[index] = ord;
+  distances[index] = distance;
+}
+function pushHeap(heap, ord, distance) {
+  ensureListCapacity(heap, heap.size + 1);
+  const start = heap.size;
+  heap.size += 1;
+  if (heap.greatestFirst) siftUpGreatestFirst(heap.ords, heap.distances, start, ord, distance);
+  else siftUpLeastFirst(heap.ords, heap.distances, start, ord, distance);
+}
+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) {
+    const size = heap.size;
+    const ord = heap.ords[size];
+    const distance = heap.distances[size];
+    if (heap.greatestFirst) siftDownGreatestFirst(heap.ords, heap.distances, size, ord, distance);
+    else siftDownLeastFirst(heap.ords, heap.distances, size, ord, distance);
+  }
+  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 readNeighborsLocked(state, ord, layer) {
+  for (; ; ) {
+    const version = beginNodeRead(state.locks, ord);
+    const count = readNeighbors(state.adjacency, ord, layer, state.neighborScratch);
+    if (nodeReadHeld(state.locks, ord, version)) return count;
+  }
+}
+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 scratch = state.neighborScratch;
+  const stamp = nextVisitStamp(state);
+  resetHeap(frontier);
+  resetHeap(found);
+  let furthestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < workspace.entryPointCount; i++) {
+    const epOrd = workspace.entryPoints[i];
+    ensureVisited(state, epOrd + 1);
+    if (state.visited[epOrd] === stamp) continue;
+    state.visited[epOrd] = stamp;
+    if (!nodeExists(state, epOrd)) continue;
+    if (skipTombstones && isTombstoned(state, epOrd)) continue;
+    const dist = getDistance(epOrd);
+    if (dist === Number.POSITIVE_INFINITY) continue;
+    pushHeap(frontier, epOrd, dist);
+    pushHeap(found, epOrd, dist);
+    if (found.size > ef) {
+      popHeap(found);
+    }
+  }
+  if (found.size > 0) furthestDist = found.distances[0];
+  while (popHeap(frontier)) {
+    if (frontier.topDistance > furthestDist) break;
+    const count = readNeighborsLocked(state, frontier.topOrd, layer);
+    for (let i = 0; i < count; i++) {
+      const neighborOrd = scratch[i];
+      ensureVisited(state, neighborOrd + 1);
+      if (state.visited[neighborOrd] === stamp) continue;
+      state.visited[neighborOrd] = stamp;
+      if (skipTombstones && isTombstoned(state, neighborOrd)) continue;
+      if (!nodeExists(state, neighborOrd)) continue;
+      const dist = getDistance(neighborOrd);
+      if (dist === Number.POSITIVE_INFINITY) continue;
+      if (dist < furthestDist || found.size < ef) {
+        pushHeap(frontier, neighborOrd, dist);
+        pushHeap(found, neighborOrd, dist);
+        if (found.size > ef) {
+          popHeap(found);
+        }
+        furthestDist = found.distances[0];
+      }
+    }
+  }
+  drainHeapNearestFirst(found, results);
+}
+function selectNeighborsHeuristic(state, candidates, maxConnections, distance, selected) {
+  const working = state.workspace.working;
+  copyList(candidates, working);
+  sortListByDistance(working);
+  ensureListCapacity(selected, Math.min(maxConnections, working.size));
+  selected.size = 0;
+  for (let i = 0; i < working.size; i++) {
+    if (selected.size >= maxConnections) break;
+    const candidateOrd = working.ords[i];
+    const candidateDistance = working.distances[i];
+    let accepted = true;
+    for (let s = 0; s < selected.size; s++) {
+      const distBetween = distance(candidateOrd, selected.ords[s]);
+      if (candidateDistance >= distBetween) {
+        accepted = false;
+        break;
+      }
+    }
+    if (!accepted) continue;
+    selected.ords[selected.size] = candidateOrd;
+    selected.distances[selected.size] = candidateDistance;
+    selected.size += 1;
+  }
+}
+function pruneConnections(state, ord, layer, distance) {
+  const adjacency = state.adjacency;
+  const base = layerBase(adjacency, ord, layer);
+  if (base === -1) return;
+  const mc = maxConns(state, layer);
+  const neighbors = layerArray(adjacency, layer);
+  const count = neighbors[base];
+  if (count <= mc) return;
+  const candidates = state.workspace.pruneCandidates;
+  candidates.size = 0;
+  ensureListCapacity(candidates, count);
+  for (let i = 1; i <= count; i++) {
+    const connOrd = neighbors[base + i];
+    const dist = distance(ord, connOrd);
+    if (dist === Number.POSITIVE_INFINITY) continue;
+    candidates.ords[candidates.size] = connOrd;
+    candidates.distances[candidates.size] = dist;
+    candidates.size += 1;
+  }
+  const kept = state.workspace.pruneSelection;
+  selectNeighborsHeuristic(state, candidates, mc, distance, kept);
+  replaceNeighbors(adjacency, ord, layer, kept.ords, kept.size);
+}
+
+// src/vector/hnsw/mutation.ts
+function clearTombstone(state, ord) {
+  if (!reachTombstone(state, ord) || Atomics.load(state.tombstones, ord) !== 1) return;
+  Atomics.sub(state.header, GRAPH_TOMBSTONE_COUNT, 1);
+  Atomics.store(state.tombstones, ord, 0);
+}
+function highestNode(state, includeTombstoned) {
+  let bestOrd = -1;
+  let bestLayer = -1;
+  const slots = adjacencySlots(state.adjacency);
+  for (let ord = 0; ord < slots; ord++) {
+    const level2 = nodeMaxLayer(state, ord);
+    if (level2 === -1) continue;
+    if (!includeTombstoned && isTombstoned(state, ord)) continue;
+    if (level2 > bestLayer) {
+      bestLayer = level2;
+      bestOrd = ord;
+    }
+  }
+  return bestOrd;
+}
+function setEntryPoint(state, ord) {
+  Atomics.store(state.header, GRAPH_ENTRY_POINT, ord);
+  Atomics.store(state.header, GRAPH_TOP_LAYER, ord === -1 ? -1 : nodeMaxLayer(state, ord));
+}
+function claimEntryIfEmpty(state, ord, level2) {
+  lockEntry(state.locks);
+  try {
+    if (Atomics.load(state.header, GRAPH_ENTRY_POINT) !== -1) return false;
+    Atomics.store(state.header, GRAPH_ENTRY_POINT, ord);
+    Atomics.store(state.header, GRAPH_TOP_LAYER, level2);
+    return true;
+  } finally {
+    unlockEntry(state.locks);
+  }
+}
+function raiseEntry(state, ord, level2) {
+  lockEntry(state.locks);
+  try {
+    if (level2 <= Atomics.load(state.header, GRAPH_TOP_LAYER)) return;
+    Atomics.store(state.header, GRAPH_ENTRY_POINT, ord);
+    Atomics.store(state.header, GRAPH_TOP_LAYER, level2);
+  } finally {
+    unlockEntry(state.locks);
+  }
+}
+function placementDistance(state, ord, vector) {
+  const metric = state.buildMetric;
+  const quantizer = state.quantizer;
+  if (quantizer !== void 0 && buildsFromCodes(state)) {
+    const prepared = quantizer.prepareQuery(vector);
+    if (prepared !== null) return quantizer.preparedDistance(prepared);
+  }
+  if (quantizer === void 0) return state.store.ordinalDistance(ord, metric);
+  return (candOrd) => nodeDistanceByOrd(state, ord, candOrd, metric);
+}
+function selectNeighborsPerLayer(state, ord, level2) {
+  const metric = state.buildMetric;
+  const workspace = state.workspace;
+  const candidates = workspace.traversal;
+  const entry = state.store.entryForOrdinal(ord);
+  if (entry === void 0) return -1;
+  const insertDistFn = placementDistance(state, ord, entry.vector);
+  const topLayer = topLayerOf(state);
+  setSingleEntryPoint(workspace, entryPointOf(state));
+  for (let layer = topLayer; layer > level2; layer--) {
+    searchLayer(state, entry.vector, entry.magnitude, 1, layer, metric, false, insertDistFn, candidates);
+    if (candidates.size > 0) setSingleEntryPoint(workspace, candidates.ords[0]);
+  }
+  const linkTop = Math.min(level2, topLayer);
+  const selections = linkSelectionsFor(workspace, linkTop + 1);
+  const distance = nodeDistanceFunction(state, metric);
+  for (let layer = linkTop; layer >= 0; layer--) {
+    searchLayer(state, entry.vector, entry.magnitude, state.efCons, layer, metric, false, insertDistFn, candidates);
+    selectNeighborsHeuristic(state, candidates, maxConns(state, layer), distance, selections[layer]);
+    if (candidates.size > 0) setEntryPointsFromList(workspace, candidates);
+  }
+  return linkTop;
+}
+function writeOwnLists(state, ord, linkTop) {
+  const selections = state.workspace.linkSelections;
+  lockNodeWrite(state.locks, ord);
+  try {
+    for (let layer = linkTop; layer >= 0; layer--) {
+      const selected = selections[layer];
+      replaceNeighbors(state.adjacency, ord, layer, selected.ords, selected.size);
+    }
+  } finally {
+    unlockNodeWrite(state.locks, ord);
+  }
+}
+function linkNeighborsBack(state, ord, linkTop) {
+  const distance = nodeDistanceFunction(state, state.buildMetric);
+  const selections = state.workspace.linkSelections;
+  for (let layer = linkTop; layer >= 0; layer--) {
+    const selected = selections[layer];
+    for (let i = 0; i < selected.size; i++) {
+      const neighborOrd = selected.ords[i];
+      if (layer > nodeMaxLayer(state, neighborOrd)) continue;
+      lockNodeWrite(state.locks, neighborOrd);
+      try {
+        addNeighbor(state.adjacency, neighborOrd, layer, ord);
+        pruneConnections(state, neighborOrd, layer, distance);
+      } finally {
+        unlockNodeWrite(state.locks, neighborOrd);
+      }
+    }
+  }
+}
+function linkNode(state, ord, level2) {
+  const topLayer = topLayerOf(state);
+  const linkTop = selectNeighborsPerLayer(state, ord, level2);
+  if (linkTop < 0) return;
+  writeOwnLists(state, ord, linkTop);
+  linkNeighborsBack(state, ord, linkTop);
+  if (level2 > topLayer) raiseEntry(state, ord, level2);
+}
+function writeRecordBeforePlacement(state, ord) {
+  const quantizer = state.quantizer;
+  if (quantizer === void 0 || !buildsFromCodes(state)) return;
+  quantizer.writeCodes(ord);
+}
+function placeThroughTheCore(state, ord, holdsGraphLock) {
+  let field = nativeFieldFor(state);
+  if (field === null) return false;
+  const level2 = randomLevel(state.mL);
+  for (let request = 0; request < PLACEMENT_ROOM_REQUESTS && field !== null; request++) {
+    ensureUpperRoom(state.adjacency, level2);
+    const placement = nativePlace(state, field, state.buildMetric, ord, level2, holdsGraphLock);
+    if (placement === "placed") return true;
+    if (placement === "failed") return false;
+    ensureCapacity(state, ord + 1);
+    publishGraphCapacity(state.adjacency.handles);
+    field = nativeFieldFor(state);
+  }
+  return false;
+}
+function insertNode(state, ord, holdsGraphLock = false) {
+  if (!state.store.holdsOrdinal(ord)) return false;
+  ensureCapacity(state, ord + 1);
+  if (nodeExists(state, ord)) return false;
+  writeRecordBeforePlacement(state, ord);
+  if (placeThroughTheCore(state, ord, holdsGraphLock)) return true;
+  if (nodeExists(state, ord)) return false;
+  if (!holdsGraphLock) lockGraphShared(state.locks);
+  try {
+    clearTombstone(state, ord);
+    const level2 = randomLevel(state.mL);
+    createNode(state.adjacency, ord, level2);
+    Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
+    if (claimEntryIfEmpty(state, ord, level2)) return true;
+    linkNode(state, ord, level2);
+  } finally {
+    if (!holdsGraphLock) unlockGraphShared(state.locks);
+  }
+  return true;
+}
+function removeNodeEager(state, ord, excludeOrds) {
+  const maxLayer = nodeMaxLayer(state, ord);
+  if (maxLayer === -1) return;
+  const distance = nodeDistanceFunction(state, state.buildMetric);
+  for (let layer = 0; layer <= maxLayer; layer++) {
+    const formerNeighbors = collectNeighbors(state.adjacency, ord, layer);
+    for (const neighborOrd of formerNeighbors) {
+      if (layer <= nodeMaxLayer(state, neighborOrd)) {
+        removeNeighbor(state.adjacency, neighborOrd, layer, ord);
+      }
+    }
+    for (const neighborOrd of formerNeighbors) {
+      if (layer > nodeMaxLayer(state, neighborOrd)) continue;
+      const mc = maxConns(state, layer);
+      if (neighborCount(state.adjacency, neighborOrd, layer) >= mc) continue;
+      const candidateOrds = new Set(collectNeighbors(state.adjacency, neighborOrd, layer));
+      for (const otherOrd of formerNeighbors) {
+        if (otherOrd !== neighborOrd && otherOrd !== ord) {
+          if (excludeOrds?.has(otherOrd)) continue;
+          candidateOrds.add(otherOrd);
+        }
+      }
+      const candidates = state.workspace.repairCandidates;
+      candidates.size = 0;
+      for (const candOrd of candidateOrds) {
+        const dist = distance(neighborOrd, candOrd);
+        if (dist === Number.POSITIVE_INFINITY) continue;
+        appendToList(candidates, candOrd, dist);
+      }
+      const selected = state.workspace.repairSelection;
+      selectNeighborsHeuristic(state, candidates, mc, distance, 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, distance);
+        }
+      }
+    }
+  }
+  deleteNode(state.adjacency, ord);
+  Atomics.sub(state.header, GRAPH_NODE_COUNT, 1);
+  clearTombstone(state, ord);
+  if (entryPointOf(state) === ord) {
+    if (Atomics.load(state.header, GRAPH_NODE_COUNT) === 0) {
+      setEntryPoint(state, -1);
+      return;
+    }
+    const live = highestNode(state, false);
+    setEntryPoint(state, live === -1 ? highestNode(state, true) : live);
+  }
+}
+function markTombstone(state, ord) {
+  if (!nodeExists(state, ord) || !reachTombstone(state, ord)) return;
+  const field = nativeFieldFor(state);
+  if (field !== null && nativeRemove(state, field, ord)) return;
+  if (Atomics.compareExchange(state.tombstones, ord, 0, 1) === 0) {
+    Atomics.add(state.header, GRAPH_TOMBSTONE_COUNT, 1);
+  }
+  if (entryPointOf(state) !== ord) return;
+  lockEntry(state.locks);
+  try {
+    if (entryPointOf(state) === ord) setEntryPoint(state, highestNode(state, false));
+  } finally {
+    unlockEntry(state.locks);
+  }
+}
+function compactTombstones(state) {
+  if (Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT) === 0) return;
+  const field = nativeFieldFor(state);
+  if (field !== null && nativeCompact(state, field, state.buildMetric)) return;
+  const tombstonedOrds = [];
+  const slots = adjacencySlots(state.adjacency);
+  for (let ord = 0; ord < slots; ord++) {
+    if (isTombstoned(state, ord) && nodeExists(state, ord)) {
+      tombstonedOrds.push(ord);
+    }
+  }
+  const excl = new Set(tombstonedOrds);
+  for (const ord of tombstonedOrds) {
+    removeNodeEager(state, ord, excl);
+  }
+}
+function resetGraph(state) {
+  resetAdjacency(state.adjacency);
+  state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
+  state.tombstones.fill(0);
+  Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, 0);
+  Atomics.store(state.header, GRAPH_NODE_COUNT, 0);
+  Atomics.store(state.header, GRAPH_ENTRY_POINT, -1);
+  Atomics.store(state.header, GRAPH_TOP_LAYER, -1);
+}
+function rebuild(state) {
+  const nodeCount = Atomics.load(state.header, GRAPH_NODE_COUNT);
+  if (Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT) === 0 && nodeCount === 0) return;
+  const liveOrds = [];
+  const slots = adjacencySlots(state.adjacency);
+  for (let ord = 0; ord < slots; ord++) {
+    if (nodeExists(state, ord) && !isTombstoned(state, ord)) {
+      liveOrds.push(ord);
+    }
+  }
+  resetGraph(state);
+  for (const ord of liveOrds) {
+    if (!state.store.holdsOrdinal(ord)) continue;
+    insertNode(state, ord, true);
+  }
+}
+
+// src/vector/ordinal-filter.ts
+function createOrdinalFilter(slots) {
+  return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
+}
+function addToOrdinalFilter(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return;
+  const bit = 1 << (ordinal & 7);
+  if ((filter.bits[index] & bit) !== 0) return;
+  filter.bits[index] |= bit;
+  filter.count += 1;
+}
+function ordinalFilterHas(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return false;
+  return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
+}
+function removeFromOrdinalFilter(filter, ordinal) {
+  const index = ordinal >>> 3;
+  if (index >= filter.bits.length) return;
+  const bit = 1 << (ordinal & 7);
+  if ((filter.bits[index] & bit) === 0) return;
+  filter.bits[index] &= ~bit;
+  filter.count -= 1;
+}
+function* ordinalFilterValues(filter) {
+  const bits = filter.bits;
+  for (let index = 0; index < bits.length; index++) {
+    const byte = bits[index];
+    if (byte === 0) continue;
+    for (let offset = 0; offset < 8; offset++) {
+      if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
+    }
+  }
+}
+
+// src/vector/native/walk.ts
+function copyCandidates(store, count, target) {
+  ensureListCapacity(target, count);
+  target.ords.set(store.ordinals.subarray(0, count));
+  target.distances.set(store.distances.subarray(0, count));
+  target.size = count;
+}
+function nativeTraverse(state, field, query, candidateCount, metric, candidates) {
+  const store = field.store;
+  reserveOrdinals(store, candidateCount);
+  let count;
+  try {
+    count = field.core.search(
+      field.graph,
+      store.handle,
+      query,
+      nativeMetricCode(metric),
+      candidateCount,
+      state.locks.threadSlot,
+      store.ordinals,
+      store.distances
+    );
+  } catch (error) {
+    stopUsingTheNativeSearchCore(error);
+    return false;
+  }
+  if (count < 0) return false;
+  copyCandidates(store, count, candidates);
+  return true;
+}
+function nativeRescoredHits(store, candidates, query, depth, metric, minSimilarity, filter) {
+  const nearest = Math.min(candidates.size, depth);
+  reserveOrdinals(store, nearest);
+  const ordinals = store.ordinals;
+  let kept = 0;
+  for (let i = 0; i < nearest; i++) {
+    const ord = candidates.ords[i];
+    if (filter && !ordinalFilterHas(filter, ord)) continue;
+    ordinals[kept++] = ord;
+  }
+  const distances = nativeScores(store, query, metric, kept);
+  if (distances === null) return null;
+  const hits = [];
+  for (let i = 0; i < kept; i++) {
+    if (distances[i] === Number.POSITIVE_INFINITY) continue;
+    const score = toScore(distances[i], metric);
+    if (score < minSimilarity) continue;
+    hits.push({ ord: ordinals[i], score });
+  }
+  return hits;
+}
+
+// src/vector/hnsw/search.ts
+function defaultOversample(bits, dimension) {
+  if (bits === 4 && dimension < OSQ4_NARROW_DIMENSION_LIMIT) return DEFAULT_OSQ4_NARROW_OVERSAMPLE;
+  return DEFAULT_OVERSAMPLE_BY_BITS[bits];
+}
+function traverse(state, query, k, searchMetric, options) {
+  const liveSize = nodeCountOf(state) - tombstoneCountOf(state);
+  const calibrated = activeQuantizer(state);
+  const quantizer = calibrated === void 0 || calibrated.size === 0 ? void 0 : calibrated;
+  const useQuantized = quantizer !== void 0;
+  const depth = quantizer === void 0 ? k : Math.ceil(k * (options.oversample ?? defaultOversample(quantizer.bits, state.dimension)));
+  let ef = Math.max(options.efSearch ?? DEFAULT_EF_SEARCH, depth);
+  const filter = options.filter;
+  if (filter && filter.count < liveSize) {
+    const selectivity = filter.count / liveSize;
+    ef = Math.max(ef, Math.ceil(k / Math.max(selectivity, 0.01)));
+    ef = Math.min(ef, liveSize);
+  }
+  const workspace = state.workspace;
+  const candidates = workspace.traversal;
+  const native = nativeFieldFor(state);
+  if (native !== null) {
+    candidates.size = 0;
+    if (nativeTraverse(state, native, query, ef, searchMetric, candidates)) {
+      return { candidates, depth: useQuantized ? depth : 0, arenaQuery: null, qMag: 0, native };
+    }
+  }
+  const store = state.store;
+  const arenaQuery = store.prepareQueryArena(query);
+  const qMag = arenaQuery ? arenaQuery.magnitude : magnitude(query);
+  let distFn;
+  if (quantizer !== void 0) {
+    const prepared = quantizer.prepareQuery(query);
+    if (prepared) distFn = quantizer.preparedDistance(prepared);
+  }
+  if (!distFn && arenaQuery) {
+    distFn = store.queryDistance(arenaQuery, searchMetric);
+  }
+  candidates.size = 0;
+  lockGraphShared(state.locks);
+  try {
+    const entryPoint = entryPointOf(state);
+    if (entryPoint === -1) return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
+    setSingleEntryPoint(workspace, entryPoint);
+    for (let layer = topLayerOf(state); layer >= 1; layer--) {
+      searchLayer(state, query, qMag, 1, layer, searchMetric, true, distFn, candidates);
+      if (candidates.size > 0) {
+        setSingleEntryPoint(workspace, candidates.ords[0]);
+      }
+    }
+    searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates);
+  } finally {
+    unlockGraphShared(state.locks);
+  }
+  return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
+}
+function bestFirst(a, b) {
+  return b.score - a.score || compareCodePoints(a.docId, b.docId);
+}
+function resolveEvery(hits, docIdOf) {
+  const resolved = [];
+  for (const hit of hits) {
+    const docId = docIdOf(hit.ord);
+    if (docId !== void 0) resolved.push({ ord: hit.ord, score: hit.score, docId });
+  }
+  return resolved;
+}
+function scoresDescend(hits) {
+  for (let i = 1; i < hits.length; i++) {
+    if (!(hits[i].score <= hits[i - 1].score)) return false;
+  }
+  return hits.length === 0 || !Number.isNaN(hits[0].score);
+}
+function bestResolvedHits(hits, k, docIdOf) {
+  if (!Number.isInteger(k) || k <= 0) {
+    return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
+  }
+  let ordered = hits;
+  if (!scoresDescend(ordered)) {
+    if (hits.some((hit) => Number.isNaN(hit.score))) return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
+    ordered = hits.slice().sort((a, b) => b.score - a.score);
+  }
+  const taken = [];
+  for (const hit of ordered) {
+    if (taken.length >= k && hit.score < taken[k - 1].score) break;
+    const docId = docIdOf(hit.ord);
+    if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
+  }
+  return taken.sort(bestFirst).slice(0, k);
+}
+function collectHits(state, query, k, searchMetric, minSimilarity, options) {
+  if (query.length !== state.dimension) {
+    throw new NarsilError(
+      ErrorCodes.VECTOR_DIMENSION_MISMATCH,
+      `Vector dimension mismatch: expected ${state.dimension}, got ${query.length}`,
+      { expected: state.dimension, received: query.length }
+    );
+  }
+  const liveSize = nodeCountOf(state) - tombstoneCountOf(state);
+  if (entryPointOf(state) === -1 || liveSize === 0) {
+    return [];
+  }
+  const { candidates, depth, arenaQuery, qMag, native } = traverse(state, query, k, searchMetric, options);
+  if (depth > 0) {
+    if (native === null) {
+      return rescoreWithFullPrecision(
+        state,
+        candidates,
+        query,
+        qMag,
+        arenaQuery,
+        depth,
+        searchMetric,
+        minSimilarity,
+        options.filter
+      );
+    }
+    const rescored = nativeRescoredHits(
+      native.store,
+      candidates,
+      query,
+      depth,
+      searchMetric,
+      minSimilarity,
+      options.filter
+    );
+    if (rescored !== null) return rescored;
+    const arena = state.store.prepareQueryArena(query);
+    return rescoreWithFullPrecision(
+      state,
+      candidates,
+      query,
+      arena ? arena.magnitude : magnitude(query),
+      arena,
+      depth,
+      searchMetric,
+      minSimilarity,
+      options.filter
+    );
+  }
+  const hits = [];
+  const filter = options.filter;
+  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;
+    hits.push({ ord, score });
+  }
+  return hits;
+}
+function rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter) {
+  const rescored = [];
+  const nearest = Math.min(candidates.size, depth);
+  for (let i = 0; i < nearest; i++) {
+    const ord = candidates.ords[i];
+    if (filter && !ordinalFilterHas(filter, ord)) continue;
+    let fullDistance;
+    if (arenaQuery) {
+      fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
+      if (fullDistance === Number.POSITIVE_INFINITY) continue;
+    } else {
+      const entry = entryForOrd(state, ord);
+      if (!entry) continue;
+      fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
+    }
+    const score = toScore(fullDistance, metric);
+    if (score < minSimilarity) continue;
+    rescored.push({ ord, score });
+  }
+  return rescored;
+}
+function search(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
+  const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
+  return bestResolvedHits(hits, k, docIdOf).map((hit) => ({
+    docId: hit.docId,
+    score: hit.score,
+    termFrequencies: {},
+    fieldLengths: {},
+    idf: {}
+  }));
+}
+function searchOrdinals(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
+  const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
+  return bestResolvedHits(hits, k, docIdOf);
+}
+
+// src/vector/hnsw/state.ts
+function openGraphState(handles, dimension, store, quantizer, threadSlot) {
+  const shape = graphShapeOf(handles.header);
+  const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
+  return {
+    dimension,
+    store,
+    quantizer,
+    adjacency,
+    locks: openGraphLocks(handles, threadSlot),
+    header: handles.header,
+    tombstones: fixedView(handles.tombstones, Uint8Array),
+    visited: new Uint32Array(0),
+    visitStamp: 0,
+    workspace: createHNSWWorkspace(),
+    neighborScratch: new Int32Array(adjacency.level0Stride),
+    M: shape.m,
+    Mmax0: shape.mMax0,
+    efCons: shape.efConstruction,
+    buildMetric: shape.metric,
+    mL: 1 / Math.log(shape.m)
+  };
+}
+
+// src/vector/osq/quantize.ts
+function osqBitsOf(mode) {
+  switch (mode) {
+    case "osq8":
+      return 8;
+    case "osq4":
+      return 4;
+    case "osq2":
+      return 2;
+    case "osq1":
+      return 1;
+    default:
+      return null;
+  }
+}
+function clamp(value, low, high) {
+  return Math.min(Math.max(value, low), high);
+}
+function unitNormaliseInto(target, vector) {
+  let squares = 0;
+  for (let i = 0; i < vector.length; i++) squares += vector[i] * vector[i];
+  const length = Math.sqrt(squares);
+  if (length === 0) {
+    for (let i = 0; i < vector.length; i++) target[i] = vector[i];
+    return;
+  }
+  for (let i = 0; i < vector.length; i++) target[i] = vector[i] / length;
+}
+function osqCentroid(vectors, dimension, metric) {
+  const sums = new Float64Array(dimension);
+  const scratch = new Float64Array(dimension);
+  let count = 0;
+  for (const vector of vectors) {
+    if (metric === "cosine") {
+      unitNormaliseInto(scratch, vector);
+      for (let i = 0; i < dimension; i++) sums[i] += scratch[i];
+    } else {
+      for (let i = 0; i < dimension; i++) sums[i] += vector[i];
+    }
+    count += 1;
+  }
+  if (count === 0) return null;
+  const centroid = new Float32Array(dimension);
+  if (metric === "cosine") {
+    let squares = 0;
+    for (let i = 0; i < dimension; i++) {
+      sums[i] /= count;
+      squares += sums[i] * sums[i];
+    }
+    const length = Math.sqrt(squares);
+    for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? sums[i] : sums[i] / length;
+    return centroid;
+  }
+  for (let i = 0; i < dimension; i++) centroid[i] = sums[i] / count;
+  return centroid;
+}
+function level(value, lower, upper, steps) {
+  if (upper === lower) return 0;
+  return Math.floor((clamp(value, lower, upper) - lower) * steps / (upper - lower) + 0.5);
+}
+function loss(x, lower, upper, steps, norm) {
+  let xe = 0;
+  let e = 0;
+  const width = (upper - lower) / steps;
+  for (let i = 0; i < x.length; i++) {
+    const q = lower + width * level(x[i], lower, upper, steps);
+    xe += x[i] * (x[i] - q);
+    e += (x[i] - q) * (x[i] - q);
+  }
+  return (1 - OSQ_LAMBDA) * xe * xe / norm + OSQ_LAMBDA * e;
+}
+function refine(x, lowerStart, upperStart, steps) {
+  let lower = lowerStart;
+  let upper = upperStart;
+  let norm = 0;
+  for (let i = 0; i < x.length; i++) norm += x[i] * x[i];
+  if (norm === 0 || upper === lower) return [lower, upper];
+  let best = loss(x, lower, upper, steps, norm);
+  for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
+    let daa = 0;
+    let dab = 0;
+    let dbb = 0;
+    let dax = 0;
+    let dbx = 0;
+    for (let i = 0; i < x.length; i++) {
+      const s = level(x[i], lower, upper, steps) / steps;
+      daa += (1 - s) * (1 - s);
+      dab += (1 - s) * s;
+      dbb += s * s;
+      dax += x[i] * (1 - s);
+      dbx += x[i] * s;
+    }
+    const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
+    const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
+    const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
+    const det = m0 * m2 - m1 * m1;
+    if (det === 0) return [lower, upper];
+    const a = (m2 * dax - m1 * dbx) / det;
+    const b = (m0 * dbx - m1 * dax) / det;
+    if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
+    const candidate = loss(x, a, b, steps, norm);
+    if (candidate > best) return [lower, upper];
+    lower = a;
+    upper = b;
+    best = candidate;
+  }
+  return [lower, upper];
+}
+function createOsqScratch(dimension) {
+  return { normalised: new Float64Array(dimension), centred: new Float64Array(dimension) };
+}
+function osqQuantize(vector, centroid, bits, metric, scratch) {
+  const dimension = vector.length;
+  const v = scratch.normalised;
+  if (metric === "cosine") unitNormaliseInto(v, vector);
+  else for (let i = 0; i < dimension; i++) v[i] = vector[i];
+  const x = scratch.centred;
+  let correction = 0;
+  let total = 0;
+  let minimum = Number.POSITIVE_INFINITY;
+  let maximum = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < dimension; i++) {
+    x[i] = v[i] - centroid[i];
+    correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
+    total += x[i];
+    if (x[i] < minimum) minimum = x[i];
+    if (x[i] > maximum) maximum = x[i];
+  }
+  const mean = total / dimension;
+  let spread = 0;
+  for (let i = 0; i < dimension; i++) spread += (x[i] - mean) * (x[i] - mean);
+  const std = Math.sqrt(spread / dimension);
+  const steps = OSQ_STEPS[bits];
+  const [lower, upper] = refine(
+    x,
+    clamp(mean - OSQ_GRID[bits] * std, minimum, maximum),
+    clamp(mean + OSQ_GRID[bits] * std, minimum, maximum),
+    steps
+  );
+  const levels = new Uint8Array(dimension);
+  let sum = 0;
+  for (let i = 0; i < dimension; i++) {
+    levels[i] = level(x[i], lower, upper, steps);
+    sum += levels[i];
+  }
+  return { levels, lower, upper, correction, sum };
+}
+
+// src/vector/osq/view.ts
+function openSharedQuantizer(store, layout, metric) {
+  const { dimension, bits, queryBits, codeBytes, capacity } = layout;
+  const scratch = createOsqScratch(dimension);
+  const documentTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
+  const otherTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
+  let codePresent = fixedView(store.handles.codePresent, Uint8Array);
+  let centroidDot = 0;
+  let centroidGeneration = -1;
+  let currentQuery = null;
+  const singleOrdinal = new Int32Array(1);
+  function reach(ordinal) {
+    if (ordinal < codePresent.length) return true;
+    if (ordinal >= store.handles.codePresent.byteLength) return false;
+    codePresent = fixedView(store.handles.codePresent, Uint8Array);
+    return ordinal < codePresent.length;
+  }
+  function isCalibrated() {
+    return Atomics.load(store.handles.header, STORE_CALIBRATED) === 1;
+  }
+  function recomputeCentroidDot(generation) {
+    const centroid = store.handles.centroid;
+    let total = 0;
+    for (let i = 0; i < dimension; i++) total += centroid[i] * centroid[i];
+    centroidDot = total;
+    centroidGeneration = generation;
+  }
+  function centroidDotNow() {
+    const generation = Atomics.load(store.handles.header, STORE_CALIBRATION_GENERATION);
+    if (generation !== centroidGeneration) recomputeCentroidDot(generation);
+    return centroidDot;
+  }
+  function holds(ordinal) {
+    return ordinal >= 0 && reach(ordinal) && codePresent[ordinal] === 1;
+  }
+  function recordOffset(ordinal) {
+    return slotByteOffset(layout, ordinal % capacity);
+  }
+  function markPresent(ordinal) {
+    if (Atomics.load(codePresent, ordinal) !== 0) return;
+    Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
+    Atomics.store(codePresent, ordinal, 1);
+  }
+  function writeCentroid(centroid) {
+    store.handles.centroid.set(centroid);
+    Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
+    Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
+  }
+  function* storedVectors(ordinals) {
+    for (const ordinal of ordinals) {
+      if (store.holdsOrdinal(ordinal)) yield store.vectorAt(ordinal);
+    }
+  }
+  function writeRecordOf(ordinal) {
+    if (!reach(ordinal) || !store.holdsOrdinal(ordinal)) return;
+    const code = osqQuantize(store.vectorAt(ordinal), store.handles.centroid, bits, metric, scratch);
+    const block = store.codeBlockOf(ordinal);
+    const offset = recordOffset(ordinal);
+    writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
+    markPresent(ordinal);
+  }
+  function writeCodesOf(ordinals) {
+    if (!isCalibrated() || ordinals.length === 0) return;
+    if (nativeQuantise(store.handles, metric, ordinals)) return;
+    for (const ordinal of ordinals) writeRecordOf(ordinal);
+  }
+  function stageQuery(block, query) {
+    if (block.simd === null || !block.hasScratch) return false;
+    if (block.stagedOrdinal !== QUERY_STAGED) {
+      block.bytes(block.scratchByteOffset + query.packed.length).set(query.packed, block.scratchByteOffset);
+      block.stagedOrdinal = QUERY_STAGED;
+    }
+    return true;
+  }
+  function simdQueryProducts(simd, documentOffset, queryOffset) {
+    if (bits === 8) return simd.dot_u8(documentOffset, queryOffset, dimension);
+    if (bits === 4) return simd.osq_dot_nibbles_4x4(documentOffset, queryOffset, codeBytes);
+    return simd.osq_dot_bits(documentOffset, queryOffset, codeBytes, bits);
+  }
+  function simdPairProducts(simd, offsetA, offsetB) {
+    if (bits === 8) return simd.dot_u8(offsetA, offsetB, dimension);
+    if (bits === 4) return simd.osq_dot_nibbles_4x4(offsetA, offsetB, codeBytes);
+    return simd.osq_dot_bits_pair(offsetA, offsetB, codeBytes, bits);
+  }
+  function pairProducts(bytesA, offsetA, bytesB, offsetB) {
+    if (bits === 8) return osqByteLevelProducts(bytesA, offsetA, bytesB, offsetB, dimension);
+    if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
+    return osqNarrowPairProducts(bytesA, offsetA, bytesB, offsetB, bits, codeBytes);
+  }
+  function productsAgainstQuery(block, documentOffset, query) {
+    if (block.simd !== null && stageQuery(block, query)) {
+      return simdQueryProducts(block.simd, documentOffset, block.scratchByteOffset);
+    }
+    const bytes = block.bytes(documentOffset + codeBytes);
+    if (bits === 8) return osqByteLevelProducts(bytes, documentOffset, query.packed, 0, dimension);
+    if (bits === 4) return osqNibbleProducts(bytes, documentOffset, query.packed, 0, codeBytes);
+    return osqStagedQueryProducts(bytes, documentOffset, bits, query.packed, 0, codeBytes);
+  }
+  function estimateDistance(ordinal, query) {
+    const block = store.codeBlockOf(ordinal);
+    const offset = recordOffset(ordinal);
+    const products = productsAgainstQuery(block, offset, query);
+    readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
+    return osqDistance(
+      osqEstimate(products, documentTrailer, bits, query, queryBits, dimension, centroidDotNow(), metric),
+      metric
+    );
+  }
+  function prepareQuery(query) {
+    if (!isCalibrated() || query.length !== dimension) return null;
+    const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
+    const packed = new Uint8Array(layout.queryBytes);
+    stageQueryLevels(code.levels, bits, packed);
+    for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
+    currentQuery = {
+      packed,
+      lower: code.lower,
+      upper: code.upper,
+      correction: code.correction,
+      sum: code.sum
+    };
+    return currentQuery;
+  }
+  function distanceBetween(ordA, ordB) {
+    if (!holds(ordA) || !holds(ordB)) return Number.POSITIVE_INFINITY;
+    const blockA = store.codeBlockOf(ordA);
+    const blockB = store.codeBlockOf(ordB);
+    const offsetA = recordOffset(ordA);
+    const offsetB = recordOffset(ordB);
+    let products;
+    if (blockA === blockB && blockA.simd !== null) {
+      products = simdPairProducts(blockA.simd, offsetA, offsetB);
+    } else {
+      products = pairProducts(blockA.bytes(offsetA + codeBytes), offsetA, blockB.bytes(offsetB + codeBytes), offsetB);
+    }
+    readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
+    readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
+    return osqDistance(
+      osqEstimate(products, documentTrailer, bits, otherTrailer, bits, dimension, centroidDotNow(), metric),
+      metric
+    );
+  }
+  return {
+    bits,
+    metric,
+    get size() {
+      return Atomics.load(store.handles.header, STORE_CODE_COUNT);
+    },
+    get centroid() {
+      return isCalibrated() ? store.handles.centroid : null;
+    },
+    isCalibrated,
+    holdsOrdinal: holds,
+    writeCodes(ordinal) {
+      singleOrdinal[0] = ordinal;
+      writeCodesOf(singleOrdinal);
+    },
+    writeCodesOf,
+    calibrateFrom(ordinals) {
+      if (nativeCalibrate(store.handles, metric, ordinals)) return isCalibrated();
+      const centroid = osqCentroid(storedVectors(ordinals), dimension, metric);
+      if (centroid === null) return false;
+      writeCentroid(centroid);
+      return true;
+    },
+    restoreRecord(ordinal, record) {
+      if (!reach(ordinal) || record.length !== layout.slotStride) return;
+      const block = store.codeBlockOf(ordinal);
+      const offset = recordOffset(ordinal);
+      block.bytes(offset + layout.slotStride).set(record, offset);
+      markPresent(ordinal);
+    },
+    recordAt(ordinal) {
+      const block = store.codeBlockOf(ordinal);
+      const offset = recordOffset(ordinal);
+      return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
+    },
+    clearCodes(ordinal) {
+      if (ordinal < 0 || !reach(ordinal)) return;
+      if (Atomics.exchange(codePresent, ordinal, 0) === 1) Atomics.sub(store.handles.header, STORE_CODE_COUNT, 1);
+    },
+    writeCentroid,
+    resetCalibration() {
+      Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
+      store.handles.centroid.fill(0);
+      Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
+    },
+    resetCodes() {
+      codePresent = fixedView(store.handles.codePresent, Uint8Array);
+      codePresent.fill(0);
+      Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
+    },
+    prepareQuery,
+    distanceFromPreparedByOrdinal(prepared, ordinal) {
+      if (!holds(ordinal)) return Number.POSITIVE_INFINITY;
+      return estimateDistance(ordinal, prepared);
+    },
+    preparedDistance(prepared) {
+      const generic = (ordinal) => holds(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
+      if (store.handles.codeBlocks.length === 0) return generic;
+      const block = store.codeBlockOf(0);
+      const simd = block.simd;
+      if (simd === null || !block.hasScratch) return generic;
+      const presentView = codePresent;
+      const limit = Math.min(presentView.length, capacity);
+      const data = block.data(0);
+      const dataLength = data.byteLength;
+      const queryOffset = block.scratchByteOffset;
+      const { slotsOffset, slotStride } = layout;
+      return (ordinal) => {
+        if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
+        if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
+        const offset = slotsOffset + ordinal * slotStride;
+        if (offset + slotStride > dataLength) return generic(ordinal);
+        const products = simdQueryProducts(simd, offset, queryOffset);
+        readTrailer(data, offset, codeBytes, documentTrailer);
+        const estimate = osqEstimate(
+          products,
+          documentTrailer,
+          bits,
+          prepared,
+          queryBits,
+          dimension,
+          centroidDotNow(),
+          metric
+        );
+        return osqDistance(estimate, metric);
+      };
+    },
+    distanceBetweenOrdinals: distanceBetween,
+    pairDistance() {
+      if (store.handles.codeBlocks.length === 0) return distanceBetween;
+      const block = store.codeBlockOf(0);
+      const simd = block.simd;
+      if (simd === null) return distanceBetween;
+      const presentView = codePresent;
+      const limit = Math.min(presentView.length, capacity);
+      const data = block.data(0);
+      const dataLength = data.byteLength;
+      const { slotsOffset, slotStride } = layout;
+      return (ordA, ordB) => {
+        if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
+        if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
+        const offsetA = slotsOffset + ordA * slotStride;
+        const offsetB = slotsOffset + ordB * slotStride;
+        if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
+        const products = simdPairProducts(simd, offsetA, offsetB);
+        readTrailer(data, offsetA, codeBytes, documentTrailer);
+        readTrailer(data, offsetB, codeBytes, otherTrailer);
+        const estimate = osqEstimate(
+          products,
+          documentTrailer,
+          bits,
+          otherTrailer,
+          bits,
+          dimension,
+          centroidDotNow(),
+          metric
+        );
+        return osqDistance(estimate, metric);
+      };
+    }
+  };
+}
+function createVectorFileReader() {
+  const descriptors = /* @__PURE__ */ new Map();
+  function descriptorOf(path) {
+    const open = descriptors.get(path);
+    if (open !== void 0) return open;
+    try {
+      const descriptor = openSync(path, "r");
+      descriptors.set(path, descriptor);
+      return descriptor;
+    } catch {
+      return null;
+    }
+  }
+  function closeDescriptor(path, descriptor) {
+    descriptors.delete(path);
+    try {
+      closeSync(descriptor);
+    } catch {
+    }
+  }
+  return {
+    readInto(path, offset, target) {
+      const descriptor = descriptorOf(path);
+      if (descriptor === null) return false;
+      let read = 0;
+      while (read < target.byteLength) {
+        let chunk;
+        try {
+          chunk = readSync(descriptor, target, read, target.byteLength - read, offset + read);
+        } catch {
+          closeDescriptor(path, descriptor);
+          return false;
+        }
+        if (chunk <= 0) return false;
+        read += chunk;
+      }
+      return true;
+    },
+    retainOnly(paths) {
+      for (const [path, descriptor] of descriptors) {
+        if (!paths.has(path)) closeDescriptor(path, descriptor);
+      }
+    },
+    close() {
+      for (const [path, descriptor] of descriptors) closeDescriptor(path, descriptor);
+    }
+  };
+}
+
+// src/vector/vector-store/hot-block-distance.ts
+function jsDistance(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 inMemory(reads, ordinal) {
+  return ordinal >= 0 && ordinal < reads.limit && reads.diskFile[ordinal] === IN_MEMORY;
+}
+function queryDistanceOf(source, prepared, metric) {
+  const generic = (ordinal) => source.distanceFromArena(prepared, ordinal, metric);
+  const reads = source.hotBlockReads();
+  const simd = reads?.block.simd ?? null;
+  if (reads === null || simd === null || !reads.block.hasScratch) return generic;
+  const { block, present, magnitudes, slotsOffset, slotStride, dimension } = reads;
+  const scratchOffset = block.scratchByteOffset;
+  const queryMagnitude = prepared.magnitude;
+  return (ordinal) => {
+    if (!inMemory(reads, ordinal) || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
+    if (present[ordinal] !== 1) return Number.POSITIVE_INFINITY;
+    const slotOffset = slotsOffset + ordinal * slotStride;
+    return arenaFloat32Distance(simd, scratchOffset, slotOffset, dimension, metric, queryMagnitude, magnitudes[ordinal]);
+  };
+}
+function pairDistanceOf(source, metric) {
+  const generic = (ordA, ordB) => source.distanceByOrdinal(ordA, ordB, metric);
+  const reads = source.hotBlockReads();
+  const simd = reads?.block.simd ?? null;
+  if (reads === null || simd === null) return generic;
+  const { present, magnitudes, slotsOffset, slotStride, dimension } = reads;
+  return (ordA, ordB) => {
+    if (!inMemory(reads, ordA) || !inMemory(reads, ordB) || present[ordA] !== 1) return generic(ordA, ordB);
+    if (present[ordB] !== 1) return Number.POSITIVE_INFINITY;
+    const offsetA = slotsOffset + ordA * slotStride;
+    const offsetB = slotsOffset + ordB * slotStride;
+    return arenaFloat32Distance(simd, offsetA, offsetB, dimension, metric, magnitudes[ordA], magnitudes[ordB]);
+  };
+}
+function ordinalDistanceOf(source, from, metric) {
+  const pair = pairDistanceOf(source, metric);
+  return (ordinal) => pair(from, ordinal);
+}
+
+// src/vector/vector-store/view.ts
+var decoder = new TextDecoder();
+var NOT_HELD = 0;
+var HELD_COLD = 1;
+var HELD_HOT = 2;
+function openSharedVectorStore(initial, threadSlot) {
+  let handles = initial;
+  const { dimension, layout } = initial;
+  const capacity = layout.capacity;
+  const codeCapacity = initial.codeLayout?.capacity ?? 1;
+  const blocks = [];
+  const codeBlocks = [];
+  let present = fixedView(handles.present, Uint8Array);
+  let magnitudes = fixedView(handles.magnitudes, Float64Array);
+  let partitions = fixedView(handles.partitions, Int32Array);
+  let docIdBytes = fixedView(handles.docIdBytes, Uint8Array);
+  let docIdOffsets = fixedView(handles.docIdOffsets, Uint32Array);
+  let diskFile = fixedView(handles.diskFile, Int32Array);
+  let diskOffset = fixedView(handles.diskOffset, Uint32Array);
+  let currentQuery = null;
+  let reader = null;
+  const coldScratchA = new Float32Array(dimension);
+  const coldScratchB = new Float32Array(dimension);
+  function rebind() {
+    present = fixedView(handles.present, Uint8Array);
+    magnitudes = fixedView(handles.magnitudes, Float64Array);
+    partitions = fixedView(handles.partitions, Int32Array);
+    docIdBytes = fixedView(handles.docIdBytes, Uint8Array);
+    docIdOffsets = fixedView(handles.docIdOffsets, Uint32Array);
+    diskFile = fixedView(handles.diskFile, Int32Array);
+    diskOffset = fixedView(handles.diskOffset, Uint32Array);
+  }
+  function blockAt(index) {
+    let block = blocks[index];
+    if (block === void 0) {
+      const handle = handles.blocks[index];
+      if (handle === null || handle === void 0) {
+        throw new Error(`Vector block ${index} holds no vectors on this thread`);
+      }
+      block = openVectorBlock(handle, threadSlot);
+      blocks[index] = block;
+    }
+    return block;
+  }
+  function codeBlockAt(index) {
+    let block = codeBlocks[index];
+    if (block === void 0) {
+      block = openVectorBlock(handles.codeBlocks[index], threadSlot);
+      codeBlocks[index] = block;
+    }
+    return block;
+  }
+  function fileOf(ordinal) {
+    if (ordinal >= diskFile.length) {
+      if (ordinal * 4 >= handles.diskFile.byteLength) return IN_MEMORY;
+      rebind();
+    }
+    return diskFile[ordinal];
+  }
+  function isCold(ordinal) {
+    return fileOf(ordinal) !== IN_MEMORY;
+  }
+  function holdState(ordinal) {
+    if (ordinal < 0) return NOT_HELD;
+    if (ordinal >= present.length) {
+      if (ordinal >= handles.present.byteLength) return NOT_HELD;
+      rebind();
+    }
+    if (present[ordinal] !== 1) return NOT_HELD;
+    if (isCold(ordinal)) return HELD_COLD;
+    const index = Math.floor(ordinal / capacity);
+    return index < handles.blocks.length && handles.blocks[index] !== null ? HELD_HOT : NOT_HELD;
+  }
+  function holds(ordinal) {
+    return holdState(ordinal) !== NOT_HELD;
+  }
+  function readFromFile(file, offset, target) {
+    const path = handles.vectorFiles[file];
+    if (path === void 0 || path.length === 0) return false;
+    if (reader === null) reader = createVectorFileReader();
+    const bytes = new Uint8Array(target.buffer, target.byteOffset, target.byteLength);
+    return reader.readInto(path, offset, bytes);
+  }
+  function readColdInto(ordinal, target) {
+    const file = fileOf(ordinal);
+    if (file === IN_MEMORY) return false;
+    if (ordinal >= diskOffset.length) rebind();
+    return readFromFile(file, diskOffset[ordinal], target);
+  }
+  function vectorIn(block, local) {
+    const base = slotByteOffset(layout, local) / 4;
+    return block.float32(base + dimension).subarray(base, base + dimension);
+  }
+  function hotVector(ordinal) {
+    return vectorIn(blockAt(ordinal / capacity | 0), ordinal % capacity);
+  }
+  function vectorFor(ordinal, scratch) {
+    if (!isCold(ordinal)) return hotVector(ordinal);
+    return readColdInto(ordinal, scratch) ? scratch : null;
+  }
+  function stageVector(block, ordinal) {
+    if (block.stagedOrdinal === ordinal) return true;
+    const source = vectorFor(ordinal, coldScratchA);
+    if (source === null) return false;
+    block.float32(0).set(source, block.scratchByteOffset / 4);
+    block.stagedOrdinal = ordinal;
+    return true;
+  }
+  function hotBlockReads() {
+    const handle = handles.blocks[0];
+    if (handle === null || handle === void 0) return null;
+    const { slotsOffset, slotStride } = layout;
+    const limit = Math.min(present.length, diskFile.length, magnitudes.length, capacity);
+    return { block: blockAt(0), present, diskFile, magnitudes, limit, slotsOffset, slotStride, dimension };
+  }
+  function stageQuery(block) {
+    if (currentQuery === null) return false;
+    if (block.stagedOrdinal !== QUERY_STAGED) {
+      block.float32(0).set(currentQuery, block.scratchByteOffset / 4);
+      block.stagedOrdinal = QUERY_STAGED;
+    }
+    return true;
+  }
+  const view = {
+    dimension,
+    threadSlot,
+    get handles() {
+      return handles;
+    },
+    get slots() {
+      return Atomics.load(handles.header, STORE_SLOTS);
+    },
+    get simdAvailable() {
+      const first = handles.blocks.find((block2) => block2 !== null);
+      if (first === void 0) return false;
+      const block = blockAt(handles.blocks.indexOf(first));
+      return block.simd !== null && block.hasScratch;
+    },
+    get holdsEveryBlock() {
+      return Atomics.load(handles.header, STORE_BLOCK_COUNT) <= handles.blocks.length && Atomics.load(handles.header, STORE_CODE_BLOCK_COUNT) <= handles.codeBlocks.length;
+    },
+    adoptHandles(next) {
+      detachNativeStore(handles);
+      handles = next;
+      rebind();
+      for (let index = 0; index < next.blocks.length; index++) {
+        if (next.blocks[index] === null) blocks[index] = void 0;
+        else if (blocks[index] === void 0) blockAt(index);
+      }
+      for (let index = codeBlocks.length; index < next.codeBlocks.length; index++) codeBlockAt(index);
+      reader?.retainOnly(new Set(next.vectorFiles.filter((path) => path.length > 0)));
+    },
+    rebind,
+    holdsOrdinal: holds,
+    isCold,
+    readColdInto,
+    readFromFile,
+    close() {
+      detachNativeStore(handles);
+      reader?.close();
+      reader = null;
+    },
+    blockOf(ordinal) {
+      return blockAt(ordinal / capacity | 0);
+    },
+    localOrdinal(ordinal) {
+      return ordinal % capacity;
+    },
+    codeBlockOf(ordinal) {
+      return codeBlockAt(ordinal / codeCapacity | 0);
+    },
+    codeLocalOrdinal(ordinal) {
+      return ordinal % codeCapacity;
+    },
+    openCodeBlocks() {
+      return codeBlocks;
+    },
+    vectorAt(ordinal) {
+      if (!isCold(ordinal)) return hotVector(ordinal);
+      const copy = new Float32Array(dimension);
+      if (!readColdInto(ordinal, copy)) {
+        throw new NarsilError(
+          ErrorCodes.PERSISTENCE_LOAD_FAILED,
+          `The vector at ordinal ${ordinal} is missing from its checkpoint file`,
+          { ordinal, path: handles.vectorFiles[fileOf(ordinal)] }
+        );
+      }
+      return copy;
+    },
+    magnitudeAt(ordinal) {
+      if (ordinal >= magnitudes.length) rebind();
+      return magnitudes[ordinal];
+    },
+    entryForOrdinal(ordinal) {
+      if (!holds(ordinal)) return void 0;
+      return { vector: view.vectorAt(ordinal), magnitude: magnitudes[ordinal] };
+    },
+    docIdAt(ordinal) {
+      if (ordinal < 0 || ordinal >= view.slots) return void 0;
+      if (ordinal + 1 >= docIdOffsets.length) rebind();
+      const start = docIdOffsets[ordinal];
+      const end = docIdOffsets[ordinal + 1];
+      if (end <= start) return void 0;
+      if (end > docIdBytes.length) rebind();
+      return decoder.decode(docIdBytes.subarray(start, end));
+    },
+    partitionAt(ordinal) {
+      if (ordinal < 0) return void 0;
+      if (ordinal >= partitions.length) {
+        if (ordinal * 4 >= handles.partitions.byteLength) return void 0;
+        rebind();
+      }
+      const partition = partitions[ordinal];
+      return partition < 0 ? void 0 : partition;
+    },
+    distanceByOrdinal(ordA, ordB, metric) {
+      if (!holds(ordA) || !holds(ordB)) return Number.POSITIVE_INFINITY;
+      if (!isCold(ordB)) {
+        const indexA = ordA / capacity | 0;
+        const indexB = ordB / capacity | 0;
+        const blockB = blockAt(indexB);
+        const localB = ordB % capacity;
+        if (blockB.simd !== null) {
+          if (indexA === indexB && !isCold(ordA)) {
+            return arenaFloat32Distance(
+              blockB.simd,
+              slotByteOffset(layout, ordA % capacity),
+              slotByteOffset(layout, localB),
+              dimension,
+              metric,
+              magnitudes[ordA],
+              magnitudes[ordB]
+            );
+          }
+          if (blockB.hasScratch && stageVector(blockB, ordA)) {
+            return arenaFloat32Distance(
+              blockB.simd,
+              blockB.scratchByteOffset,
+              slotByteOffset(layout, localB),
+              dimension,
+              metric,
+              magnitudes[ordA],
+              magnitudes[ordB]
+            );
+          }
+        }
+      }
+      const a = vectorFor(ordA, coldScratchA);
+      const b = vectorFor(ordB, coldScratchB);
+      if (a === null || b === null) return Number.POSITIVE_INFINITY;
+      return jsDistance(a, b, magnitudes[ordA], magnitudes[ordB], metric);
+    },
+    prepareQueryArena(query) {
+      if (query.length !== dimension || !view.simdAvailable) return null;
+      currentQuery = query;
+      for (const block of blocks) {
+        if (block !== void 0) block.stagedOrdinal = NOTHING_STAGED;
+      }
+      return { magnitude: magnitude(query) };
+    },
+    distanceFromArena(prepared, ordinal, metric) {
+      const state = holdState(ordinal);
+      if (state === NOT_HELD) return Number.POSITIVE_INFINITY;
+      if (currentQuery === null) return Number.POSITIVE_INFINITY;
+      if (state === HELD_COLD) {
+        if (!readColdInto(ordinal, coldScratchA)) return Number.POSITIVE_INFINITY;
+        return jsDistance(currentQuery, coldScratchA, prepared.magnitude, magnitudes[ordinal], metric);
+      }
+      const block = blockAt(ordinal / capacity | 0);
+      const local = ordinal % capacity;
+      if (block.simd !== null && block.hasScratch && stageQuery(block)) {
+        return arenaFloat32Distance(
+          block.simd,
+          block.scratchByteOffset,
+          slotByteOffset(layout, local),
+          dimension,
+          metric,
+          prepared.magnitude,
+          magnitudes[ordinal]
+        );
+      }
+      return jsDistance(currentQuery, vectorIn(block, local), prepared.magnitude, magnitudes[ordinal], metric);
+    },
+    hotBlockReads,
+    queryDistance: (prepared, metric) => queryDistanceOf(view, prepared, metric),
+    ordinalDistance: (from, metric) => ordinalDistanceOf(view, from, metric),
+    pairDistance: (metric) => pairDistanceOf(view, metric)
+  };
+  for (let index = 0; index < handles.blocks.length; index++) {
+    if (handles.blocks[index] !== null) blockAt(index);
+  }
+  for (let index = 0; index < handles.codeBlocks.length; index++) codeBlockAt(index);
+  return view;
+}
+
+// src/vector/shared-field/view.ts
+function openSharedVectorField(initial, threadSlot) {
+  let handles = initial;
+  const store = openSharedVectorStore(initial.store, threadSlot);
+  const codeLayout = initial.store.codeLayout;
+  const quantizer = initial.quantization !== "none" && codeLayout !== null ? openSharedQuantizer(store, codeLayout, initial.metric) : void 0;
+  let graph = null;
+  let ordinals = null;
+  let scanned = 0;
+  let placed = 0;
+  function openGraph(next) {
+    graph = next.graph === null ? null : openGraphState(next.graph, next.dimension, store, quantizer, threadSlot);
+  }
+  openGraph(initial);
+  function docIdOf(ordinal) {
+    if (!store.holdsOrdinal(ordinal)) return void 0;
+    return store.docIdAt(ordinal);
+  }
+  function ordinalOf(docId) {
+    const slots = store.slots;
+    if (ordinals === null) ordinals = /* @__PURE__ */ new Map();
+    for (; scanned < slots; scanned++) {
+      const id = store.docIdAt(scanned);
+      if (id !== void 0) ordinals.set(id, scanned);
+    }
+    const ordinal = ordinals.get(docId);
+    return ordinal !== void 0 && store.holdsOrdinal(ordinal) ? ordinal : void 0;
+  }
+  return {
+    get handles() {
+      return handles;
+    },
+    store,
+    quantizer,
+    get graph() {
+      return graph;
+    },
+    get liveSize() {
+      return graph === null ? 0 : nodeCountOf(graph) - tombstoneCountOf(graph);
+    },
+    get readsEveryVector() {
+      return store.holdsEveryBlock;
+    },
+    docIdOf,
+    ordinalOf,
+    vectorOf(docId) {
+      const ordinal = ordinalOf(docId);
+      return ordinal === void 0 ? void 0 : store.vectorAt(ordinal);
+    },
+    adopt(next) {
+      store.adoptHandles(next.store);
+      if (next.graph?.header !== handles.graph?.header) openGraph(next);
+      handles = next;
+    },
+    close() {
+      store.close();
+    },
+    insertOrdinal(ordinal) {
+      if (graph === null) return false;
+      const fresh = insertNode(graph, ordinal);
+      if (fresh) placed += 1;
+      return fresh;
+    },
+    takeOutcome() {
+      const outcome = { placed };
+      placed = 0;
+      return outcome;
+    },
+    searchOrdinals(query, k, metric, minSimilarity, options) {
+      if (graph === null) return [];
+      return searchOrdinals(graph, docIdOf, query, k, metric, minSimilarity, options);
+    }
+  };
+}
+
+// src/vector/osq/index.ts
+function createOsqQuantizer(dimension, bits, metric, store) {
+  let opened = null;
+  function shared() {
+    if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
+      opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
+    }
+    return opened;
+  }
+  function requireShared() {
+    const view = shared();
+    if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
+    return view;
+  }
+  function ordinalOf(docId) {
+    const ordinal = store.getOrdinal(docId);
+    if (ordinal === void 0) {
+      throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
+    }
+    return ordinal;
+  }
+  return {
+    dimension,
+    bits,
+    metric,
+    get size() {
+      return shared()?.size ?? 0;
+    },
+    get centroid() {
+      return shared()?.centroid ?? null;
+    },
+    isCalibrated: () => shared()?.isCalibrated() ?? false,
+    calibrate(ordinals) {
+      if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
+    },
+    quantize(docId) {
+      const ordinal = ordinalOf(docId);
+      const view = requireShared();
+      if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
+      view.writeCodes(ordinal);
+    },
+    writeCodes(ordinal) {
+      shared()?.writeCodes(ordinal);
+    },
+    remove(docId) {
+      const ordinal = store.getOrdinal(docId);
+      if (ordinal !== void 0) shared()?.clearCodes(ordinal);
+    },
+    removeOrdinal(ordinal) {
+      shared()?.clearCodes(ordinal);
+    },
+    hasOrdinal: (ordinal) => shared()?.holdsOrdinal(ordinal) ?? false,
+    getLevels(docId) {
+      const view = shared();
+      const ordinal = store.getOrdinal(docId);
+      if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
+      return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
+    },
+    recordOf(docId) {
+      const view = shared();
+      const ordinal = store.getOrdinal(docId);
+      if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
+      return view.recordAt(ordinal);
+    },
+    restoreRecord(docId, record) {
+      requireShared().restoreRecord(ordinalOf(docId), record);
+    },
+    restoreCentroid(centroid) {
+      requireShared().writeCentroid(centroid);
+    },
+    recalibrate(ordinals) {
+      if (ordinals.length === 0) return;
+      const view = requireShared();
+      view.resetCodes();
+      view.calibrateFrom(ordinals);
+      view.writeCodesOf(ordinals);
+    },
+    prepareQuery: (query) => shared()?.prepareQuery(query) ?? null,
+    distanceFromPreparedByOrdinal: (prepared, ordinal) => shared()?.distanceFromPreparedByOrdinal(prepared, ordinal) ?? Number.POSITIVE_INFINITY,
+    preparedDistance(prepared) {
+      const view = shared();
+      if (view === null) return () => Number.POSITIVE_INFINITY;
+      return view.preparedDistance(prepared);
+    },
+    pairDistance() {
+      const view = shared();
+      if (view === null) return () => Number.POSITIVE_INFINITY;
+      return view.pairDistance();
+    },
+    distanceBetweenOrdinals: (ordA, ordB) => shared()?.distanceBetweenOrdinals(ordA, ordB) ?? Number.POSITIVE_INFINITY,
+    clear() {
+      const view = shared();
+      if (view === null) return;
+      view.resetCodes();
+      view.resetCalibration();
+    }
+  };
+}
+
+// src/vector/vector-store/doc-ids.ts
+var encoder = new TextEncoder();
+function appendDocId(handles, ordinal, docId) {
+  const bytes = encoder.encode(docId);
+  const start = Atomics.load(handles.header, STORE_DOC_ID_BYTES);
+  const end = start + bytes.length;
+  growBufferTo(handles.docIdBytes, end);
+  growBufferTo(handles.docIdOffsets, (ordinal + 2) * 4);
+  new Uint8Array(handles.docIdBytes).set(bytes, start);
+  const offsets = new Uint32Array(handles.docIdOffsets);
+  offsets[ordinal] = start;
+  offsets[ordinal + 1] = end;
+  Atomics.store(handles.header, STORE_DOC_ID_BYTES, end);
+}
+function resetDocIds(handles) {
+  new Uint32Array(handles.docIdOffsets).fill(0);
+  Atomics.store(handles.header, STORE_DOC_ID_BYTES, 0);
+}
+
+// src/vector/vector-store/open-store.ts
+function openHandles(dimension, codeBits, blockBytes2) {
+  const handles = createSharedVectorStoreHandles(dimension, codeBits, blockBytes2);
+  return {
+    handles,
+    view: openSharedVectorStore(handles, 0),
+    magnitudes: new Float64Array(handles.magnitudes),
+    present: new Uint8Array(handles.present),
+    partitions: new Int32Array(handles.partitions),
+    diskFile: new Int32Array(handles.diskFile),
+    diskOffset: new Uint32Array(handles.diskOffset)
+  };
+}
+function relayout(store) {
+  store.handles.layoutRevision += 1;
+  store.view.adoptHandles(store.handles);
+}
+function ensureCodeSlot(store, ordinal) {
+  const { handles } = store;
+  if (handles.codeLayout === null) return;
+  const blockIndex = Math.floor(ordinal / handles.codeLayout.capacity);
+  while (handles.codeBlocks.length <= blockIndex) {
+    handles.codeBlocks.push(createVectorBlock(handles.codeLayout));
+    Atomics.store(handles.header, STORE_CODE_BLOCK_COUNT, handles.codeBlocks.length);
+    relayout(store);
+  }
+  ensureBlockSlots(handles.codeBlocks[blockIndex], ordinal % handles.codeLayout.capacity + 1);
+}
+function ensureFloatSlot(store, ordinal) {
+  const { handles } = store;
+  const blockIndex = Math.floor(ordinal / handles.layout.capacity);
+  let changed = false;
+  while (handles.blocks.length <= blockIndex) {
+    handles.blocks.push(null);
+    changed = true;
+  }
+  if (handles.blocks[blockIndex] === null) {
+    handles.blocks[blockIndex] = createVectorBlock(handles.layout);
+    changed = true;
+  }
+  if (changed) {
+    Atomics.store(handles.header, STORE_BLOCK_COUNT, handles.blocks.length);
+    relayout(store);
+  }
+  const block = handles.blocks[blockIndex];
+  if (block !== null) ensureBlockSlots(block, ordinal % handles.layout.capacity + 1);
+}
+function ensureOrdinal(store, ordinal, cold) {
+  if (ordinal >= MAX_VECTOR_ORDINALS) {
+    throw new NarsilError(
+      ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
+      `A vector field holds at most ${MAX_VECTOR_ORDINALS} vectors, deleted ones included, until it is rebuilt`,
+      { ordinal, maxOrdinals: MAX_VECTOR_ORDINALS }
+    );
+  }
+  const { handles } = store;
+  growBufferTo(handles.magnitudes, (ordinal + 1) * 8);
+  growBufferTo(handles.present, ordinal + 1);
+  growBufferTo(handles.partitions, (ordinal + 1) * 4);
+  growBufferTo(handles.codePresent, ordinal + 1);
+  const diskFileBytes = handles.diskFile.byteLength;
+  growBufferTo(handles.diskFile, (ordinal + 1) * 4);
+  if (handles.diskFile.byteLength > diskFileBytes) {
+    new Int32Array(handles.diskFile).fill(IN_MEMORY, diskFileBytes / 4);
+  }
+  growBufferTo(handles.diskOffset, (ordinal + 1) * 4);
+  if (!cold) ensureFloatSlot(store, ordinal);
+  ensureCodeSlot(store, ordinal);
+}
+function writeVector(store, ordinal, vector) {
+  const block = store.view.blockOf(ordinal);
+  const base = slotByteOffset(store.handles.layout, store.view.localOrdinal(ordinal)) / 4;
+  block.float32(base + vector.length).set(vector, base);
+  store.magnitudes[ordinal] = magnitude(vector);
+}
+function blockFullyCold(store, blockIndex, documents) {
+  const capacity = store.handles.layout.capacity;
+  const slots = Atomics.load(store.handles.header, STORE_SLOTS);
+  const end = Math.min(slots, (blockIndex + 1) * capacity);
+  if (end < (blockIndex + 1) * capacity) return false;
+  for (let ordinal = blockIndex * capacity; ordinal < end; ordinal++) {
+    if (documents[ordinal] !== void 0 && store.diskFile[ordinal] === IN_MEMORY) return false;
+  }
+  return true;
+}
+function fileHoldsSameBytes(store, ordinal, location) {
+  const fromFile = new Float32Array(store.handles.dimension);
+  if (!store.view.readFromFile(location.fileIndex, location.offset, fromFile)) return false;
+  const held = store.view.vectorAt(ordinal);
+  const a = new Uint8Array(fromFile.buffer);
+  const b = new Uint8Array(held.buffer, held.byteOffset, held.byteLength);
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function forgetUnreferencedFiles(store, documents) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (let ordinal = 0; ordinal < documents.length; ordinal++) {
+    if (documents[ordinal] !== void 0 && store.diskFile[ordinal] !== IN_MEMORY) {
+      referenced.add(store.diskFile[ordinal]);
+    }
+  }
+  let forgotten = 0;
+  for (let file = 0; file < store.handles.vectorFiles.length; file++) {
+    if (referenced.has(file) || store.handles.vectorFiles[file] === "") continue;
+    store.handles.vectorFiles[file] = "";
+    forgotten += 1;
+  }
+  return forgotten;
+}
+function partitionFilterOf(store, documents, partitionIds) {
+  const filter = createOrdinalFilter(documents.length);
+  if (store === null) return filter;
+  let highest = -1;
+  for (const partitionId of partitionIds) {
+    if (partitionId > highest) highest = partitionId;
+  }
+  if (highest < 0) return filter;
+  const wanted = new Uint8Array(highest + 1);
+  for (const partitionId of partitionIds) {
+    if (partitionId >= 0) wanted[partitionId] = 1;
+  }
+  for (let ordinal = 0; ordinal < documents.length; ordinal++) {
+    if (documents[ordinal] === void 0) continue;
+    const partitionId = store.partitions[ordinal];
+    if (partitionId < 0 || partitionId > highest || wanted[partitionId] === 0) continue;
+    addToOrdinalFilter(filter, ordinal);
+  }
+  return filter;
+}
+
+// src/vector/vector-store/index.ts
+var UNKNOWN_PARTITION = -1;
+var NO_PARTITION = -2;
+function createVectorStore(options) {
+  const codeBits = options?.codeBits ?? null;
+  const blockBytes2 = options?.blockBytes ?? BLOCK_MAX_BYTES;
+  const docToOrd = /* @__PURE__ */ new Map();
+  const ordToDoc = [];
+  let unknownPartitions = 0;
+  let liveCount = 0;
+  let open = options?.dimension === void 0 ? null : openHandles(options.dimension, codeBits, blockBytes2);
+  function forgetDocuments() {
+    docToOrd.clear();
+    ordToDoc.length = 0;
+    unknownPartitions = 0;
+    liveCount = 0;
+  }
+  function requireOpen() {
+    if (open === null) {
+      throw new NarsilError(ErrorCodes.VECTOR_DIMENSION_MISMATCH, "The vector store holds no vector yet");
+    }
+    return open;
+  }
+  function recordPartition(store, ordinal, partitionId) {
+    const given = partitionId !== void 0 && partitionId >= 0 ? partitionId : UNKNOWN_PARTITION;
+    store.partitions[ordinal] = given;
+    if (given === UNKNOWN_PARTITION) unknownPartitions += 1;
+  }
+  function retireOrdinal(store, ordinal) {
+    ordToDoc[ordinal] = void 0;
+    Atomics.store(store.present, ordinal, 0);
+    if (store.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
+  }
+  function claimOrdinal(store, docId, cold, partitionId) {
+    const ordinal = Atomics.load(store.handles.header, STORE_SLOTS);
+    ensureOrdinal(store, ordinal, cold);
+    store.diskFile[ordinal] = IN_MEMORY;
+    appendDocId(store.handles, ordinal, docId);
+    recordPartition(store, ordinal, partitionId);
+    ordToDoc[ordinal] = docId;
+    docToOrd.set(docId, ordinal);
+    return ordinal;
+  }
+  function publishOrdinal(store, ordinal) {
+    Atomics.store(store.handles.header, STORE_SLOTS, ordinal + 1);
+    Atomics.store(store.present, ordinal, 1);
+  }
+  function appendOrdinal(store, docId, vector, partitionId) {
+    const ordinal = claimOrdinal(store, docId, false, partitionId);
+    writeVector(store, ordinal, vector);
+    publishOrdinal(store, ordinal);
+    return ordinal;
+  }
+  function settleReplacement(store, ordinal, previous) {
+    if (previous !== void 0) {
+      retireOrdinal(store, previous);
+      return ordinal;
+    }
+    liveCount++;
+    Atomics.add(store.handles.header, STORE_LIVE_COUNT, 1);
+    return ordinal;
+  }
+  function entryAt(store, ordinal) {
+    return { vector: store.view.vectorAt(ordinal), magnitude: store.magnitudes[ordinal] };
+  }
+  return {
+    get size() {
+      return liveCount;
+    },
+    get slots() {
+      return ordToDoc.length;
+    },
+    get dimension() {
+      return open === null ? 0 : open.handles.dimension;
+    },
+    get codeBits() {
+      return codeBits;
+    },
+    get handles() {
+      return requireOpen().handles;
+    },
+    get view() {
+      return requireOpen().view;
+    },
+    insert(docId, vector, partitionId) {
+      if (open === null) open = openHandles(vector.length, codeBits, blockBytes2);
+      const store = open;
+      if (vector.length !== store.handles.dimension) {
+        throw new NarsilError(
+          ErrorCodes.VECTOR_DIMENSION_MISMATCH,
+          `Vector dimension mismatch: expected ${store.handles.dimension}, got ${vector.length}`,
+          { expected: store.handles.dimension, received: vector.length }
+        );
+      }
+      const previous = docToOrd.get(docId);
+      const ordinal = appendOrdinal(store, docId, vector, partitionId);
+      return settleReplacement(store, ordinal, previous);
+    },
+    insertCold(docId, vectorMagnitude, location, partitionId) {
+      const store = requireOpen();
+      const previous = docToOrd.get(docId);
+      Atomics.store(store.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 1);
+      const ordinal = claimOrdinal(store, docId, true, partitionId);
+      store.magnitudes[ordinal] = vectorMagnitude;
+      store.diskOffset[ordinal] = location.offset;
+      store.diskFile[ordinal] = location.fileIndex;
+      publishOrdinal(store, ordinal);
+      return settleReplacement(store, ordinal, previous);
+    },
+    addVectorFile(path) {
+      const store = requireOpen();
+      const existing = store.handles.vectorFiles.indexOf(path);
+      if (existing !== -1) return existing;
+      store.handles.vectorFiles.push(path);
+      relayout(store);
+      return store.handles.vectorFiles.length - 1;
+    },
+    isCold(ordinal) {
+      if (open === null) return false;
+      return open.view.isCold(ordinal);
+    },
+    releaseToFile(ordinal, location) {
+      const store = requireOpen();
+      if (ordToDoc[ordinal] === void 0) return false;
+      if (store.diskFile[ordinal] === IN_MEMORY && !fileHoldsSameBytes(store, ordinal, location)) return false;
+      Atomics.store(store.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 1);
+      store.diskOffset[ordinal] = location.offset;
+      store.diskFile[ordinal] = location.fileIndex;
+      return true;
+    },
+    releaseColdBlocks() {
+      const store = requireOpen();
+      let released = 0;
+      for (let index = 0; index < store.handles.blocks.length; index++) {
+        if (store.handles.blocks[index] === null || !blockFullyCold(store, index, ordToDoc)) continue;
+        store.handles.blocks[index] = null;
+        released += 1;
+      }
+      if (released + forgetUnreferencedFiles(store, ordToDoc) > 0) relayout(store);
+      return released;
+    },
+    setPartition(docId, partitionId) {
+      const ordinal = docToOrd.get(docId);
+      if (ordinal === void 0 || open === null || partitionId < 0) return;
+      if (open.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
+      open.partitions[ordinal] = partitionId;
+    },
+    forgetPartition(docId) {
+      const ordinal = docToOrd.get(docId);
+      if (ordinal === void 0 || open === null) return;
+      if (open.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
+      open.partitions[ordinal] = NO_PARTITION;
+    },
+    partitionOfOrdinal(ordinal) {
+      if (open === null || ordinal < 0 || ordinal >= ordToDoc.length) return void 0;
+      const partitionId = open.partitions[ordinal];
+      return partitionId < 0 ? void 0 : partitionId;
+    },
+    get partitionsKnown() {
+      return unknownPartitions === 0;
+    },
+    partitionFilter(partitionIds) {
+      return partitionFilterOf(open, ordToDoc, partitionIds);
+    },
+    remove(docId) {
+      const ordinal = docToOrd.get(docId);
+      if (ordinal === void 0 || open === null) return;
+      docToOrd.delete(docId);
+      retireOrdinal(open, ordinal);
+      liveCount--;
+      Atomics.sub(open.handles.header, STORE_LIVE_COUNT, 1);
+    },
+    get(docId) {
+      const ordinal = docToOrd.get(docId);
+      return ordinal === void 0 || open === null ? void 0 : entryAt(open, ordinal);
+    },
+    has(docId) {
+      return docToOrd.has(docId);
+    },
+    holdsOrdinal(ordinal) {
+      return ordinal >= 0 && ordinal < ordToDoc.length && ordToDoc[ordinal] !== void 0;
+    },
+    *entries() {
+      if (open === null) return;
+      for (let ordinal = 0; ordinal < ordToDoc.length; ordinal++) {
+        const docId = ordToDoc[ordinal];
+        if (docId === void 0) continue;
+        yield [docId, entryAt(open, ordinal)];
+      }
+    },
+    clear() {
+      forgetDocuments();
+      if (open === null) return;
+      open.present.fill(0);
+      new Uint8Array(open.handles.codePresent).fill(0);
+      new Int32Array(open.handles.diskFile).fill(IN_MEMORY);
+      open.handles.centroid.fill(0);
+      if (open.handles.vectorFiles.length > 0) {
+        open.handles.vectorFiles.length = 0;
+        relayout(open);
+      }
+      resetDocIds(open.handles);
+      Atomics.store(open.handles.header, STORE_SLOTS, 0);
+      Atomics.store(open.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 0);
+      Atomics.store(open.handles.header, STORE_LIVE_COUNT, 0);
+      Atomics.store(open.handles.header, STORE_CODE_COUNT, 0);
+      Atomics.store(open.handles.header, STORE_CALIBRATED, 0);
+      Atomics.add(open.handles.header, STORE_CALIBRATION_GENERATION, 1);
+    },
+    release() {
+      forgetDocuments();
+      open?.view.close();
+      open = null;
+    },
+    closeFiles: () => open?.view.close(),
+    getOrdinal(docId) {
+      return docToOrd.get(docId);
+    },
+    docIdForOrdinal(ordinal) {
+      return ordToDoc[ordinal];
+    },
+    entryForOrdinal(ordinal) {
+      if (open === null || ordinal < 0 || ordinal >= ordToDoc.length || ordToDoc[ordinal] === void 0) {
+        return void 0;
+      }
+      return entryAt(open, ordinal);
+    },
+    distanceByOrdinal(ordA, ordB, metric) {
+      if (open === null || ordToDoc[ordA] === void 0 || ordToDoc[ordB] === void 0) {
+        return Number.POSITIVE_INFINITY;
+      }
+      return open.view.distanceByOrdinal(ordA, ordB, metric);
+    },
+    prepareQueryArena(query) {
+      return open === null ? null : open.view.prepareQueryArena(query);
+    },
+    distanceFromArena(prepared, ordinal, metric) {
+      if (open === null || ordToDoc[ordinal] === void 0) return Number.POSITIVE_INFINITY;
+      return open.view.distanceFromArena(prepared, ordinal, metric);
+    },
+    queryDistance(prepared, metric) {
+      if (open === null) return () => Number.POSITIVE_INFINITY;
+      const inner = open.view.queryDistance(prepared, metric);
+      return (ordinal) => ordToDoc[ordinal] === void 0 ? Number.POSITIVE_INFINITY : inner(ordinal);
+    },
+    ordinalDistance(from, metric) {
+      const pair = this.pairDistance(metric);
+      return (ordinal) => pair(from, ordinal);
+    },
+    pairDistance(metric) {
+      if (open === null) return () => Number.POSITIVE_INFINITY;
+      const inner = open.view.pairDistance(metric);
+      return (ordA, ordB) => ordToDoc[ordA] === void 0 || ordToDoc[ordB] === void 0 ? Number.POSITIVE_INFINITY : inner(ordA, ordB);
+    },
+    exportSnapshot() {
+      const slots = ordToDoc.length;
+      const dimension = open === null ? 0 : open.handles.dimension;
+      const vectors = new Float32Array(slots * dimension);
+      const magnitudes = new Float64Array(slots);
+      const docIds = new Array(slots);
+      for (let ordinal = 0; ordinal < slots; ordinal++) {
+        const docId = ordToDoc[ordinal];
+        docIds[ordinal] = docId ?? null;
+        if (docId === void 0 || open === null) continue;
+        vectors.set(open.view.vectorAt(ordinal), ordinal * dimension);
+        magnitudes[ordinal] = open.magnitudes[ordinal];
+      }
+      return { dimension, slots, vectors, magnitudes, docIds };
+    },
+    restoreSnapshot(snapshot) {
+      this.clear();
+      if (snapshot.dimension === 0 || snapshot.slots === 0) return;
+      if (open === null) open = openHandles(snapshot.dimension, codeBits, blockBytes2);
+      const store = open;
+      for (let ordinal = 0; ordinal < snapshot.slots; ordinal++) {
+        const docId = snapshot.docIds[ordinal];
+        const vector = snapshot.vectors.subarray(ordinal * snapshot.dimension, (ordinal + 1) * snapshot.dimension);
+        if (docId === null || docId === void 0) {
+          ensureOrdinal(store, ordinal, false);
+          ordToDoc[ordinal] = void 0;
+          store.partitions[ordinal] = NO_PARTITION;
+          Atomics.store(store.handles.header, STORE_SLOTS, ordinal + 1);
+          continue;
+        }
+        appendOrdinal(store, docId, vector);
+        liveCount++;
+      }
+      Atomics.store(store.handles.header, STORE_LIVE_COUNT, liveCount);
+    },
+    memoryBytes() {
+      return open === null ? 0 : sharedVectorStoreBytes(open.handles);
+    }
+  };
+}
+
+// src/vector/hnsw/numbered-graph.ts
+var NO_NUMBER = -1;
+var NO_ORDINAL = -1;
+var NO_LAYER = -1;
+var BYTES_PER_VALUE = 4;
+var LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+function swapEveryValue(bytes) {
+  for (let i = 0; i + 3 < bytes.length; i += BYTES_PER_VALUE) {
+    const first = bytes[i];
+    const second = bytes[i + 1];
+    bytes[i] = bytes[i + 3];
+    bytes[i + 1] = bytes[i + 2];
+    bytes[i + 2] = second;
+    bytes[i + 3] = first;
+  }
+}
+function littleEndianBytesOf(values) {
+  const bytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+  if (!LITTLE_ENDIAN) swapEveryValue(bytes);
+  return bytes;
+}
+function valuesOf(bytes) {
+  if (LITTLE_ENDIAN && bytes.byteOffset % BYTES_PER_VALUE === 0) {
+    return new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / BYTES_PER_VALUE));
+  }
+  const copy = bytes.slice(0, bytes.byteLength - bytes.byteLength % BYTES_PER_VALUE);
+  if (!LITTLE_ENDIAN) swapEveryValue(copy);
+  return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
+}
+function savedTopLayer(state, ordinal) {
+  if (ordinal === NO_ORDINAL || isTombstoned(state, ordinal)) return NO_LAYER;
+  return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
+}
+function largestNeighbourValueCount(state, topLayers) {
+  let values = 0;
+  for (let number = 0; number < topLayers.length; number++) {
+    const top = topLayers[number];
+    if (top < 0) continue;
+    values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
+  }
+  return values;
+}
+function serializeNumberedGraph(state, numberOfOrdinal, ordinalOfNumber) {
+  const adjacency = state.adjacency;
+  const slots = adjacencySlots(adjacency);
+  const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
+  const levels = new Uint8Array(ordinalOfNumber.length);
+  for (let number = 0; number < ordinalOfNumber.length; number++) {
+    const ordinal = ordinalOfNumber[number];
+    if (ordinal >= slots) continue;
+    topLayers[number] = savedTopLayer(state, ordinal);
+    levels[number] = topLayers[number] + 1;
+  }
+  const values = new Uint32Array(largestNeighbourValueCount(state, topLayers));
+  let cursor = 0;
+  for (let number = 0; number < ordinalOfNumber.length; number++) {
+    const top = topLayers[number];
+    for (let layer = 0; layer <= top; layer++) {
+      const base = layerBase(adjacency, ordinalOfNumber[number], layer);
+      const array = layerArray(adjacency, layer);
+      const held = base === -1 ? 0 : Math.min(array[base], maxConns(state, layer));
+      const countAt = cursor;
+      cursor += 1;
+      for (let i = 1; i <= held; i++) {
+        const neighbourOrdinal = array[base + i];
+        if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
+        const neighbour = numberOfOrdinal[neighbourOrdinal];
+        if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
+        values[cursor] = neighbour;
+        cursor += 1;
+      }
+      values[countAt] = cursor - countAt - 1;
+    }
+  }
+  const entryOrdinal = entryPointOf(state);
+  const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
+  const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
+  return {
+    entryPoint: entryHoldsNode ? entryNumber : null,
+    maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
+    m: state.M,
+    efConstruction: state.efCons,
+    metric: state.buildMetric,
+    levels,
+    neighbours: littleEndianBytesOf(values.subarray(0, cursor))
+  };
+}
+function endsInsideAList() {
+  throw new NarsilError(
+    ErrorCodes.PERSISTENCE_LOAD_FAILED,
+    "Invalid vector graph payload: neighbours ends inside a list"
+  );
+}
+function requireWholeNeighbourLists(graph) {
+  const values = valuesOf(graph.neighbours);
+  if (values.length * BYTES_PER_VALUE !== graph.neighbours.byteLength) endsInsideAList();
+  let cursor = 0;
+  for (let number = 0; number < graph.levels.length; number++) {
+    for (let layer = 0; layer < graph.levels[number]; layer++) {
+      if (cursor >= values.length) endsInsideAList();
+      const count = values[cursor];
+      if (count > values.length - cursor - 1) endsInsideAList();
+      cursor += count + 1;
+    }
+  }
+}
+function topLayerIn(graph, number) {
+  return number < graph.levels.length ? graph.levels[number] - 1 : -1;
+}
+function deserializeNumberedGraph(state, graph, ordinalOfNumber) {
+  requireWholeNeighbourLists(graph);
+  resetGraph(state);
+  const values = valuesOf(graph.neighbours);
+  const ordinalAt = (number) => number < ordinalOfNumber.length ? ordinalOfNumber[number] : NO_ORDINAL;
+  let highestOrdinal = -1;
+  for (let number = 0; number < graph.levels.length; number++) {
+    if (graph.levels[number] > 0 && ordinalAt(number) > highestOrdinal) highestOrdinal = ordinalAt(number);
+  }
+  if (highestOrdinal >= 0) ensureCapacity(state, highestOrdinal + 1);
+  const kept = [];
+  let cursor = 0;
+  let highestLayer = -1;
+  let nodeOnHighestLayer = NO_ORDINAL;
+  for (let number = 0; number < graph.levels.length; number++) {
+    const top = graph.levels[number] - 1;
+    if (top < 0) continue;
+    const ordinal = ordinalAt(number);
+    const keptTop = Math.min(top, MAX_LAYER_CAP);
+    if (ordinal !== NO_ORDINAL) {
+      createNode(state.adjacency, ordinal, keptTop);
+      Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
+      if (keptTop > highestLayer) {
+        highestLayer = keptTop;
+        nodeOnHighestLayer = ordinal;
+      }
+    }
+    for (let layer = 0; layer <= top; layer++) {
+      const count = values[cursor];
+      kept.length = 0;
+      const limit = maxConns(state, layer);
+      for (let i = 1; i <= count && kept.length < limit; i++) {
+        const neighbour = values[cursor + i];
+        const neighbourOrdinal = ordinalAt(neighbour);
+        if (neighbourOrdinal === NO_ORDINAL || neighbour === number || topLayerIn(graph, neighbour) < layer) continue;
+        if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
+      }
+      cursor += count + 1;
+      if (ordinal !== NO_ORDINAL && layer <= keptTop) {
+        replaceNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
+      }
+    }
+  }
+  const entryOrdinal = graph.entryPoint === null ? NO_ORDINAL : ordinalAt(graph.entryPoint);
+  const entryTop = graph.entryPoint === null ? -1 : Math.min(topLayerIn(graph, graph.entryPoint), MAX_LAYER_CAP);
+  const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
+  Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
+  Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
+}
+
+// src/vector/hnsw/persistence.ts
+function serializeGraph(state, store) {
+  const nodeArray = [];
+  const slots = adjacencySlots(state.adjacency);
+  for (let ord = 0; ord < slots; ord++) {
+    const maxLayer = nodeMaxLayer(state, ord);
+    if (maxLayer === -1) continue;
+    if (isTombstoned(state, ord)) continue;
+    const docId = store.docIdForOrdinal(ord);
+    if (docId === void 0) continue;
+    const layerConns = [];
+    for (let layer = 0; layer <= maxLayer; layer++) {
+      const liveNeighbors = [];
+      for (const neighborOrd of collectNeighbors(state.adjacency, ord, layer)) {
+        if (isTombstoned(state, neighborOrd)) continue;
+        const neighborDoc = store.docIdForOrdinal(neighborOrd);
+        if (neighborDoc === void 0) continue;
+        liveNeighbors.push(neighborDoc);
+      }
+      if (liveNeighbors.length > 0) {
+        layerConns.push([layer, liveNeighbors]);
+      }
+    }
+    nodeArray.push([docId, maxLayer, layerConns]);
+  }
+  const entryOrd = entryPointOf(state);
+  const entryPoint = entryOrd === -1 ? null : store.docIdForOrdinal(entryOrd) ?? null;
+  return {
+    entryPoint,
+    maxLayer: topLayerOf(state),
+    m: state.M,
+    efConstruction: state.efCons,
+    metric: state.buildMetric,
+    nodes: nodeArray
+  };
+}
+function resolveNodes(state, store, data) {
+  const nodes = [];
+  let maxOrd = -1;
+  for (const [docId, maxLayer, layerConns] of data.nodes) {
+    const ord = store.getOrdinal(docId);
+    if (ord === void 0 || !store.holdsOrdinal(ord)) continue;
+    const clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
+    const layers = [];
+    for (const [layer, neighbors] of layerConns) {
+      if (layer < 0 || layer > clampedMaxLayer) continue;
+      const limit = maxConns(state, layer);
+      const resolved = [];
+      for (const neighborDoc of neighbors) {
+        if (resolved.length >= limit) break;
+        const neighborOrd = store.getOrdinal(neighborDoc);
+        if (neighborOrd === void 0) continue;
+        addConnection(resolved, neighborOrd);
+        if (neighborOrd > maxOrd) maxOrd = neighborOrd;
+      }
+      layers.push([layer, resolved]);
+    }
+    if (ord > maxOrd) maxOrd = ord;
+    nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
+  }
+  return { nodes, maxOrd };
+}
+function deserializeGraph(state, store, data) {
+  resetGraph(state);
+  const { nodes, maxOrd } = resolveNodes(state, store, data);
+  if (maxOrd >= 0) {
+    ensureCapacity(state, maxOrd + 1);
+  }
+  for (const node of nodes) {
+    createNode(state.adjacency, node.ord, node.maxLayer);
+    for (const [layer, neighbors] of node.layers) {
+      replaceNeighbors(state.adjacency, node.ord, layer, neighbors, neighbors.length);
+    }
+    Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
+  }
+  if (data.entryPoint != null && data.entryPoint !== "") {
+    const epOrd = store.getOrdinal(data.entryPoint);
+    if (epOrd !== void 0 && nodeExists(state, epOrd)) {
+      Atomics.store(state.header, GRAPH_ENTRY_POINT, epOrd);
+      Atomics.store(state.header, GRAPH_TOP_LAYER, Math.min(Math.max(data.maxLayer, 0), MAX_LAYER_CAP));
+    }
+  }
+  if (entryPointOf(state) === -1 && Atomics.load(state.header, GRAPH_NODE_COUNT) > 0) {
+    let bestOrd = -1;
+    let bestLayer = -1;
+    const slots = adjacencySlots(state.adjacency);
+    for (let ord = 0; ord < slots; ord++) {
+      const level2 = nodeMaxLayer(state, ord);
+      if (level2 === -1) continue;
+      if (level2 > bestLayer) {
+        bestLayer = level2;
+        bestOrd = ord;
+      }
+    }
+    Atomics.store(state.header, GRAPH_ENTRY_POINT, bestOrd);
+    Atomics.store(state.header, GRAPH_TOP_LAYER, bestLayer);
+  }
+}
+
+// src/vector/hnsw/scratch-bytes.ts
+function listBytes(list) {
+  return list.ords.byteLength + list.distances.byteLength;
+}
+function workspaceBytes(workspace) {
+  let bytes = listBytes(workspace.frontier) + listBytes(workspace.found) + listBytes(workspace.traversal) + listBytes(workspace.working) + listBytes(workspace.pruneCandidates) + listBytes(workspace.pruneSelection) + listBytes(workspace.repairCandidates) + listBytes(workspace.repairSelection) + workspace.entryPoints.byteLength;
+  for (const list of workspace.linkSelections) bytes += listBytes(list);
+  return bytes;
+}
+function searchScratchBytes(state) {
+  const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
+  const native = attachedNativeField(state);
+  return native === null ? held : held + nativeScratchBytes(state, native);
+}
+
+// src/vector/hnsw/snapshot.ts
+function exportSnapshot(state) {
+  const adj = state.adjacency;
+  const slots = adjacencySlots(adj);
+  const used = upperUsed(adj);
+  const stride = adj.level0Stride;
+  rebindNodes(adj);
+  reachTombstone(state, slots);
+  return {
+    dimension: state.dimension,
+    m: state.M,
+    efConstruction: state.efCons,
+    metric: state.buildMetric,
+    slots,
+    upperUsed: used,
+    nodeLevels: adj.nodeLevels.slice(0, slots),
+    level0: adj.level0.slice(0, slots * stride),
+    upperBase: adj.upperBase.slice(0, slots),
+    upper: adj.upper.slice(0, used),
+    tombstones: state.tombstones.slice(0, slots),
+    tombstoneCount: Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT),
+    nodeCount: Atomics.load(state.header, GRAPH_NODE_COUNT),
+    entryPointOrd: Atomics.load(state.header, GRAPH_ENTRY_POINT),
+    topLayer: Atomics.load(state.header, GRAPH_TOP_LAYER)
+  };
+}
+function restoreSnapshot(state, snapshot) {
+  resetGraph(state);
+  const adj = state.adjacency;
+  ensureAdjacencyCapacity(adj, snapshot.slots);
+  adj.nodeLevels.set(snapshot.nodeLevels);
+  adj.level0.set(snapshot.level0);
+  adj.upperBase.set(snapshot.upperBase);
+  ensureUpperCapacity(adj, snapshot.upper.length);
+  adj.upper.set(snapshot.upper);
+  Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
+  Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
+  state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
+  state.tombstones.set(snapshot.tombstones);
+  Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
+  Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
+  Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
+  Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
+}
+
+// src/vector/hnsw/index.ts
+function createHNSWIndex(dimension, store, config, quantizer, handles) {
+  const M = config?.m ?? 16;
+  const shared = handles ?? createSharedGraphHandles({
+    m: M,
+    mMax0: M * 2,
+    efConstruction: config?.efConstruction ?? 200,
+    metric: config?.metric ?? "cosine"
+  });
+  const state = openGraphState(shared, dimension, store, quantizer, 0);
+  const docIdOf = (ord) => store.docIdForOrdinal(ord);
+  function exclusively(operation) {
+    lockGraphExclusive(state.locks);
+    try {
+      return operation();
+    } finally {
+      unlockGraphExclusive(state.locks);
+    }
+  }
+  function insertNode2(docId) {
+    const ord = store.getOrdinal(docId);
+    if (ord === void 0) {
+      throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
+    }
+    const entry = store.entryForOrdinal(ord);
+    if (!entry) {
+      throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
+    }
+    if (entry.vector.length !== dimension) {
+      throw new Error(`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`);
+    }
+    insertNode(state, ord);
+  }
+  function* entriesIterator() {
+    const slots = adjacencySlots(state.adjacency);
+    for (let ord = 0; ord < slots; ord++) {
+      if (!hasNode(state.adjacency, ord)) continue;
+      if (isTombstoned(state, ord)) continue;
+      const docId = store.docIdForOrdinal(ord);
+      if (docId === void 0) continue;
+      const entry = store.entryForOrdinal(ord);
+      if (!entry) continue;
+      yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
+    }
+  }
+  function compactionNeeded() {
+    const nodeCount = nodeCountOf(state);
+    if (nodeCount === 0) return false;
+    const tombstones = tombstoneCountOf(state);
+    return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
+  }
+  return {
+    get dimension() {
+      return dimension;
+    },
+    get size() {
+      return nodeCountOf(state) - tombstoneCountOf(state);
+    },
+    get tombstoneCount() {
+      return tombstoneCountOf(state);
+    },
+    get entryPointId() {
+      const entryPoint = entryPointOf(state);
+      return entryPoint === -1 ? null : store.docIdForOrdinal(entryPoint) ?? null;
+    },
+    get topLayer() {
+      return topLayerOf(state);
+    },
+    get m() {
+      return state.M;
+    },
+    get efConstruction() {
+      return state.efCons;
+    },
+    get metric() {
+      return state.buildMetric;
+    },
+    get graphBytes() {
+      return graphBytes(state.adjacency);
+    },
+    get searchScratchBytes() {
+      return searchScratchBytes(state);
+    },
+    get handles() {
+      return shared;
+    },
+    insertNode: insertNode2,
+    insertOrdinal: (ordinal) => insertNode(state, ordinal),
+    markTombstone: (docId) => {
+      const ord = store.getOrdinal(docId);
+      if (ord !== void 0) markTombstone(state, ord);
+    },
+    markTombstoneOrdinal: (ordinal) => markTombstone(state, ordinal),
+    has: (docId) => {
+      const ord = store.getOrdinal(docId);
+      return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
+    },
+    isTombstoned: (docId) => {
+      const ord = store.getOrdinal(docId);
+      return ord !== void 0 && isTombstoned(state, ord);
+    },
+    search: (query, k, searchMetric, minSimilarity, options) => search(state, docIdOf, query, k, searchMetric, minSimilarity, options),
+    clear: () => exclusively(() => resetGraph(state)),
+    entries: entriesIterator,
+    compactionNeeded,
+    compactTombstones: () => exclusively(() => compactTombstones(state)),
+    rebuild: () => exclusively(() => rebuild(state)),
+    exclusively,
+    serialize: () => serializeGraph(state, store),
+    deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
+    serializeNumbered: (numberOfOrdinal, ordinalOfNumber) => serializeNumberedGraph(state, numberOfOrdinal, ordinalOfNumber),
+    deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
+    exportSnapshot: () => exportSnapshot(state),
+    restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
+  };
+}
+
+export { DISK_STORAGE_BLOCK_BYTES, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, MAX_WORKER_COPIES, SCRATCH_SLOTS_PER_THREAD_POOL, STORE_CALIBRATION_GENERATION, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_SEARCH_TIMEOUT_MS, addToOrdinalFilter, cosineSimilarityWithMagnitudes, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createVectorStore, dotProduct, entryForOrd, euclideanDistance, isSimdAvailable, isTombstoned, magnitude, nativeScoresOf, nativeStoreScratchBytes, noteFallback, openSharedVectorField, ordinalFilterHas, ordinalFilterValues, osqBitsOf, osqRecordBytes, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, sharedMemoryAvailable, toDistance, toScore };