@delali/narsil 0.2.4-next.48 → 0.2.4-next.50

package/dist/chunk-CMVG2UEF.mjs

@@ -0,0 +1,2038 @@
+import { MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, RESULT_WINDOW, DEFAULT_PAGE_SIZE, PREFIX_MAX_EXPANSIONS, MAX_CURSOR_ANCHOR_CODE_POINTS } from './chunk-CBLS46IE.mjs';
+import { MAX_M } from './chunk-RP23PWMV.mjs';
+import { compareCodePoints, compareComparableKeys, toComparableSortValue, readSortField, SORT_VALUE_MAX_CODE_POINTS, compareSortValues } from './chunk-2GWVQWGA.mjs';
+import { createNarsilError, ErrorCodes, NarsilError } from './chunk-P4ELXVJQ.mjs';
+
+// src/core/tokenizer/constants.ts
+var TOKEN_CACHE_SIZE_FLOOR = 5e4;
+var TOKEN_CACHE_SIZE_CEILING = 2e6;
+var TOKEN_CACHE_BYTES_PER_ENTRY = 200;
+var NODE_TOKEN_CACHE_ENTRIES = 1e6;
+var UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES = 2e5;
+var CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION = 0.05;
+var SMALL_DEVICE_MEMORY_GB = 1;
+var MEDIUM_DEVICE_MEMORY_GB = 4;
+var SMALL_DEVICE_TOKEN_CACHE_ENTRIES = 1e5;
+var MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES = 25e4;
+var LARGE_DEVICE_TOKEN_CACHE_ENTRIES = 5e5;
+var DEFAULT_MIN_TOKEN_LENGTH = 1;
+
+// src/core/tokenizer/normalize.ts
+var DOTTED_CAPITAL_I = "\u0130";
+var COMBINING_DOT_ABOVE = "\u0307";
+var ARMENIAN_MARKS = /[\u055B-\u055F]/;
+var FOLDED_FORMS = /\u0307|[\u0130\u055B-\u055F\u2018\u2019\u02BC\u02BB]/g;
+var WIDTH_FORMS = /[\uFF01-\uFF5E\uFF61-\uFF9F]/;
+var WIDTH_FORMS_GLOBAL = /[\uFF01-\uFF5E\uFF61-\uFF9F]/g;
+var FULLWIDTH_ASCII_END = 65374;
+var FULLWIDTH_ASCII_OFFSET = 65248;
+var HALFWIDTH_KANA_START = 65377;
+var HALFWIDTH_VOICED_MARK = 65438;
+var HALFWIDTH_SEMI_VOICED_MARK = 65439;
+var COMBINING_VOICED_MARK = "\u3099";
+var COMBINING_SEMI_VOICED_MARK = "\u309A";
+var HALFWIDTH_KANA_TARGETS = "\u3002\u300C\u300D\u3001\u30FB\u30F2\u30A1\u30A3\u30A5\u30A7\u30A9\u30E3\u30E5\u30E7\u30C3\u30FC\u30A2\u30A4\u30A6\u30A8\u30AA\u30AB\u30AD\u30AF\u30B1\u30B3\u30B5\u30B7\u30B9\u30BB\u30BD\u30BF\u30C1\u30C4\u30C6\u30C8\u30CA\u30CB\u30CC\u30CD\u30CE\u30CF\u30D2\u30D5\u30D8\u30DB\u30DE\u30DF\u30E0\u30E1\u30E2\u30E4\u30E6\u30E8\u30E9\u30EA\u30EB\u30EC\u30ED\u30EF\u30F3";
+function foldForm(match) {
+  if (match === DOTTED_CAPITAL_I) return "i";
+  if (match === COMBINING_DOT_ABOVE || ARMENIAN_MARKS.test(match)) return "";
+  return "'";
+}
+function foldWidth(match) {
+  const codePoint = match.charCodeAt(0);
+  if (codePoint <= FULLWIDTH_ASCII_END) return String.fromCharCode(codePoint - FULLWIDTH_ASCII_OFFSET);
+  if (codePoint === HALFWIDTH_VOICED_MARK) return COMBINING_VOICED_MARK;
+  if (codePoint === HALFWIDTH_SEMI_VOICED_MARK) return COMBINING_SEMI_VOICED_MARK;
+  return HALFWIDTH_KANA_TARGETS[codePoint - HALFWIDTH_KANA_START];
+}
+function isAscii(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) > 127) return false;
+  }
+  return true;
+}
+function foldWidthForms(text) {
+  if (!WIDTH_FORMS.test(text)) return text;
+  return text.replace(WIDTH_FORMS_GLOBAL, foldWidth);
+}
+function normalizeForSplitting(text) {
+  if (isAscii(text)) return text.toLowerCase();
+  return foldWidthForms(text).normalize("NFC").replace(FOLDED_FORMS, foldForm).toLowerCase();
+}
+function stripDiacritics(text) {
+  return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+
+// src/core/tokenizer/cache.ts
+function clampCacheSize(entries) {
+  return Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(entries, TOKEN_CACHE_SIZE_CEILING));
+}
+function computeDefaultCacheSize() {
+  try {
+    if (typeof process !== "undefined" && typeof process.versions?.node === "string" && typeof window === "undefined") {
+      const constrainedMemory = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : 0;
+      if (constrainedMemory > 0) {
+        const budget = constrainedMemory * CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION;
+        return clampCacheSize(Math.floor(budget / TOKEN_CACHE_BYTES_PER_ENTRY));
+      }
+      return clampCacheSize(NODE_TOKEN_CACHE_ENTRIES);
+    }
+    if (typeof navigator !== "undefined") {
+      const mem = navigator.deviceMemory;
+      if (typeof mem === "number" && mem > 0) {
+        let entries;
+        if (mem <= SMALL_DEVICE_MEMORY_GB) entries = SMALL_DEVICE_TOKEN_CACHE_ENTRIES;
+        else if (mem <= MEDIUM_DEVICE_MEMORY_GB) entries = MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES;
+        else entries = LARGE_DEVICE_TOKEN_CACHE_ENTRIES;
+        return clampCacheSize(entries);
+      }
+    }
+  } catch {
+    return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
+  }
+  return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
+}
+var normalizationCache = /* @__PURE__ */ new Map();
+var normalizationCacheSize = 0;
+var maxCacheSize = computeDefaultCacheSize();
+var cachedLangName = "";
+var cachedFlags = "";
+var cachedBucket = null;
+function configureNormalizationCache(maxSize) {
+  if (!Number.isFinite(maxSize)) {
+    throw createNarsilError(ErrorCodes.CONFIG_INVALID, "tokenizerCacheSize must be a finite number", {
+      received: maxSize
+    });
+  }
+  if (maxSize < 0) {
+    throw createNarsilError(ErrorCodes.CONFIG_INVALID, "tokenizerCacheSize must not be negative", {
+      received: maxSize
+    });
+  }
+  if (maxSize === 0) {
+    throw createNarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      "tokenizerCacheSize must be greater than zero; the normalization cache cannot be disabled",
+      {
+        received: maxSize
+      }
+    );
+  }
+  maxCacheSize = Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), TOKEN_CACHE_SIZE_CEILING));
+  if (normalizationCacheSize > maxCacheSize) {
+    evictOldestEntries(normalizationCacheSize - maxCacheSize);
+  }
+}
+function getCacheBucket(language, flags) {
+  const langKey = `${language.name}@${language.revision}`;
+  if (cachedBucket && langKey === cachedLangName && flags === cachedFlags) return cachedBucket;
+  const key = `${langKey}:${flags}`;
+  let bucket = normalizationCache.get(key);
+  if (!bucket) {
+    bucket = /* @__PURE__ */ new Map();
+    normalizationCache.set(key, bucket);
+  }
+  cachedLangName = langKey;
+  cachedFlags = flags;
+  cachedBucket = bucket;
+  return bucket;
+}
+function evictOldestEntries(count) {
+  let remaining = count;
+  for (const [key, bucket] of normalizationCache) {
+    if (remaining <= 0) break;
+    if (bucket.size <= remaining) {
+      remaining -= bucket.size;
+      normalizationCacheSize -= bucket.size;
+      normalizationCache.delete(key);
+      if (bucket === cachedBucket) cachedBucket = null;
+    } else {
+      let deleted = 0;
+      for (const raw of bucket.keys()) {
+        if (deleted >= remaining) break;
+        bucket.delete(raw);
+        deleted++;
+      }
+      normalizationCacheSize -= deleted;
+      remaining = 0;
+    }
+  }
+}
+function transformToken(raw, language, stem, removeDiacritics) {
+  const flags = (stem ? "s" : "") + (removeDiacritics ? "d" : "");
+  let bucket = getCacheBucket(language, flags);
+  const cached = bucket.get(raw);
+  if (cached !== void 0) return cached;
+  let normalized = raw;
+  if (language.normalizer) {
+    normalized = language.normalizer(normalized);
+  }
+  if (removeDiacritics) {
+    normalized = stripDiacritics(normalized);
+  }
+  if (stem && language.stemmer) {
+    normalized = language.stemmer(normalized);
+  }
+  if (normalizationCacheSize >= maxCacheSize) {
+    evictOldestEntries(Math.max(1, maxCacheSize >>> 2));
+    bucket = getCacheBucket(language, flags);
+  }
+  bucket.set(raw, normalized);
+  normalizationCacheSize++;
+  return normalized;
+}
+function clearNormalizationCache() {
+  normalizationCache.clear();
+  normalizationCacheSize = 0;
+  cachedBucket = null;
+}
+function resetNormalizationCache() {
+  clearNormalizationCache();
+  maxCacheSize = computeDefaultCacheSize();
+}
+function getNormalizationCacheSize() {
+  return normalizationCacheSize;
+}
+
+// src/core/tokenizer/ngrams.ts
+var OTHER_SCRIPT = 0;
+var HAN_SCRIPT = 1;
+var HIRAGANA_SCRIPT = 2;
+var KATAKANA_SCRIPT = 3;
+var HANGUL_SCRIPT = 4;
+var THAI_SCRIPT = 5;
+var LAO_SCRIPT = 6;
+var KHMER_SCRIPT = 7;
+var MYANMAR_SCRIPT = 8;
+var PROLONGED_SOUND_MARK = 12540;
+var IDEOGRAPHIC_ITERATION_MARK = 12293;
+var LOWEST_NGRAM_CODE_POINT = 3584;
+var LOWEST_MARK_CODE_POINT = 768;
+var THAI_BLOCK_END = 3711;
+var LAO_BLOCK_END = 3839;
+var MYANMAR_BLOCK_START = 4096;
+var MYANMAR_BLOCK_END = 4255;
+var KHMER_BLOCK_START = 6016;
+var KHMER_BLOCK_END = 6655;
+var SOUTHEAST_ASIAN_BLOCKS_END = 6656;
+var HIRAGANA_BLOCK_START = 12352;
+var HIRAGANA_BLOCK_END = 12447;
+var COMBINING_VOICED_MARK2 = 12441;
+var COMBINING_SEMI_VOICED_MARK2 = 12442;
+var KATAKANA_BLOCK_START = 12448;
+var KATAKANA_BLOCK_END = 12543;
+var HAN_EXTENSION_A_START = 13312;
+var HAN_EXTENSION_A_END = 19903;
+var HAN_UNIFIED_START = 19968;
+var HAN_UNIFIED_END = 40959;
+var HANGUL_SYLLABLE_START = 44032;
+var HANGUL_SYLLABLE_END = 55203;
+var HAN_COMPATIBILITY_START = 63744;
+var HAN_COMPATIBILITY_END = 64255;
+var SUPPLEMENTARY_PLANE_START = 65536;
+var MARK = /\p{M}/uy;
+var HAN = /\p{Script=Han}/uy;
+var HIRAGANA = /\p{Script=Hiragana}/uy;
+var KATAKANA = /\p{Script=Katakana}/uy;
+var HANGUL = /\p{Script=Hangul}/uy;
+var THAI = /\p{Script=Thai}/uy;
+var LAO = /\p{Script=Lao}/uy;
+var KHMER = /\p{Script=Khmer}/uy;
+var MYANMAR = /\p{Script=Myanmar}/uy;
+function matchesAt(pattern, part, index) {
+  pattern.lastIndex = index;
+  return pattern.test(part);
+}
+function isMark(part, index, codePoint) {
+  if (codePoint < LOWEST_MARK_CODE_POINT) return false;
+  if (codePoint >= HAN_UNIFIED_START && codePoint <= HAN_UNIFIED_END) return false;
+  if (codePoint >= HIRAGANA_BLOCK_START && codePoint <= KATAKANA_BLOCK_END) {
+    return codePoint === COMBINING_VOICED_MARK2 || codePoint === COMBINING_SEMI_VOICED_MARK2;
+  }
+  if (codePoint >= HANGUL_SYLLABLE_START && codePoint <= HANGUL_SYLLABLE_END) return false;
+  if (codePoint >= HAN_EXTENSION_A_START && codePoint <= HAN_EXTENSION_A_END) return false;
+  return matchesAt(MARK, part, index);
+}
+function classifyOutsideCommonBlocks(part, index) {
+  if (matchesAt(HAN, part, index)) return HAN_SCRIPT;
+  if (matchesAt(HIRAGANA, part, index)) return HIRAGANA_SCRIPT;
+  if (matchesAt(KATAKANA, part, index)) return KATAKANA_SCRIPT;
+  if (matchesAt(HANGUL, part, index)) return HANGUL_SCRIPT;
+  if (matchesAt(THAI, part, index)) return THAI_SCRIPT;
+  if (matchesAt(LAO, part, index)) return LAO_SCRIPT;
+  if (matchesAt(KHMER, part, index)) return KHMER_SCRIPT;
+  if (matchesAt(MYANMAR, part, index)) return MYANMAR_SCRIPT;
+  return OTHER_SCRIPT;
+}
+function classifySoutheastAsian(part, index, codePoint) {
+  if (codePoint <= THAI_BLOCK_END) return matchesAt(THAI, part, index) ? THAI_SCRIPT : OTHER_SCRIPT;
+  if (codePoint <= LAO_BLOCK_END) return matchesAt(LAO, part, index) ? LAO_SCRIPT : OTHER_SCRIPT;
+  if (codePoint >= MYANMAR_BLOCK_START && codePoint <= MYANMAR_BLOCK_END) {
+    return matchesAt(MYANMAR, part, index) ? MYANMAR_SCRIPT : OTHER_SCRIPT;
+  }
+  if (codePoint >= KHMER_BLOCK_START && codePoint <= KHMER_BLOCK_END) {
+    return matchesAt(KHMER, part, index) ? KHMER_SCRIPT : OTHER_SCRIPT;
+  }
+  return classifyOutsideCommonBlocks(part, index);
+}
+function classify(part, index, codePoint, current) {
+  if (codePoint < LOWEST_NGRAM_CODE_POINT) return OTHER_SCRIPT;
+  if (codePoint < SOUTHEAST_ASIAN_BLOCKS_END) return classifySoutheastAsian(part, index, codePoint);
+  if (codePoint === PROLONGED_SOUND_MARK) {
+    return current === HIRAGANA_SCRIPT ? HIRAGANA_SCRIPT : KATAKANA_SCRIPT;
+  }
+  if (codePoint >= HIRAGANA_BLOCK_START && codePoint <= HIRAGANA_BLOCK_END) return HIRAGANA_SCRIPT;
+  if (codePoint >= KATAKANA_BLOCK_START && codePoint <= KATAKANA_BLOCK_END) return KATAKANA_SCRIPT;
+  if (codePoint >= HAN_UNIFIED_START && codePoint <= HAN_UNIFIED_END) return HAN_SCRIPT;
+  if (codePoint >= HAN_EXTENSION_A_START && codePoint <= HAN_EXTENSION_A_END) return HAN_SCRIPT;
+  if (codePoint >= HANGUL_SYLLABLE_START && codePoint <= HANGUL_SYLLABLE_END) return HANGUL_SCRIPT;
+  if (codePoint >= HAN_COMPATIBILITY_START && codePoint <= HAN_COMPATIBILITY_END) return HAN_SCRIPT;
+  if (codePoint === IDEOGRAPHIC_ITERATION_MARK) return HAN_SCRIPT;
+  return classifyOutsideCommonBlocks(part, index);
+}
+function emitRun(part, offsets, kind, size, out) {
+  const count = offsets.length - 1;
+  if (count < 1) return;
+  if (kind === OTHER_SCRIPT || count <= size) {
+    out.push(part.slice(offsets[0], offsets[count]));
+    return;
+  }
+  for (let start = 0; start + size <= count; start++) {
+    out.push(part.slice(offsets[start], offsets[start + size]));
+  }
+}
+function expandNgrams(part, size, out) {
+  const length = part.length;
+  if (length === 0) return;
+  const offsets = [];
+  let kind = OTHER_SCRIPT;
+  let index = 0;
+  while (index < length) {
+    const codePoint = part.codePointAt(index);
+    if (codePoint === void 0) break;
+    const width = codePoint >= SUPPLEMENTARY_PLANE_START ? 2 : 1;
+    if (offsets.length > 0 && isMark(part, index, codePoint)) {
+      index += width;
+      continue;
+    }
+    const next = classify(part, index, codePoint, kind);
+    if (offsets.length > 0 && next !== kind) {
+      offsets.push(index);
+      emitRun(part, offsets, kind, size, out);
+      offsets.length = 0;
+    }
+    kind = next;
+    offsets.push(index);
+    index += width;
+  }
+  offsets.push(length);
+  emitRun(part, offsets, kind, size, out);
+}
+
+// src/core/tokenizer/tokenize.ts
+var DEFAULT_SPLIT_PATTERN = /[^\p{L}\p{M}\p{N}_'-]+/u;
+function resolveStopWords(language, override) {
+  if (!override) return language.stopWords;
+  if (override instanceof Set) return override;
+  return override(language.stopWords);
+}
+function splitText(text, language) {
+  const pattern = language.tokenizer?.splitPattern ?? DEFAULT_SPLIT_PATTERN;
+  const parts = text.split(pattern);
+  const ngramSize = language.tokenizer?.ngramSize;
+  if (ngramSize === void 0 || ngramSize < 1) return parts;
+  const size = Math.floor(ngramSize);
+  const expanded = [];
+  for (const part of parts) {
+    expandNgrams(part, size, expanded);
+  }
+  return expanded;
+}
+var CHAR_APOSTROPHE = 39;
+var CHAR_S = 115;
+function stripPossessive(token) {
+  const len = token.length;
+  if (len >= 2 && token.charCodeAt(len - 1) === CHAR_S && token.charCodeAt(len - 2) === CHAR_APOSTROPHE) {
+    return token.slice(0, -2);
+  }
+  if (len >= 1 && token.charCodeAt(len - 1) === CHAR_APOSTROPHE) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
+function tokenize(text, language, options) {
+  const {
+    stem = true,
+    removeStopWords = true,
+    removeDiacritics = false,
+    collectSurfaces = false,
+    customTokenizer,
+    stopWordOverride
+  } = options ?? {};
+  if (customTokenizer) {
+    const customResult = customTokenizer.tokenize(text);
+    const originals = customResult.map((t) => t.token);
+    return {
+      tokens: customResult,
+      originalTokens: originals
+    };
+  }
+  const normalized = normalizeForSplitting(text);
+  const rawParts = splitText(normalized, language);
+  const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
+  const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
+  const stemsTokens = stem && language.stemmer !== null;
+  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
+  const stripPossessives = language.tokenizer?.stripPossessive ?? false;
+  const tokens = [];
+  const originalTokens = [];
+  const surfaces = collectSurfaces && stemsTokens ? [] : void 0;
+  let position = 0;
+  for (const part of rawParts) {
+    const candidate = stripPossessives ? stripPossessive(part) : part;
+    if (candidate.length < minLength) {
+      position++;
+      continue;
+    }
+    if (stopWords.has(candidate)) {
+      position++;
+      continue;
+    }
+    const processed = transformToken(candidate, language, stem, effectiveDiacritics);
+    if (processed.length > 0) {
+      tokens.push({ token: processed, position });
+      originalTokens.push(part);
+      if (surfaces) {
+        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
+        surfaces.push(surface === processed ? void 0 : surface);
+      }
+    }
+    position++;
+  }
+  return { tokens, originalTokens, surfaces };
+}
+function* tokenizeIterator(text, language, options) {
+  const {
+    stem = true,
+    removeStopWords = true,
+    removeDiacritics = false,
+    collectSurfaces = false,
+    customTokenizer,
+    stopWordOverride
+  } = options ?? {};
+  if (customTokenizer) {
+    const customResult = customTokenizer.tokenize(text);
+    for (const entry of customResult) {
+      yield entry;
+    }
+    return;
+  }
+  const normalized = normalizeForSplitting(text);
+  const rawParts = splitText(normalized, language);
+  const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
+  const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
+  const stemsTokens = stem && language.stemmer !== null;
+  const wantSurfaces = collectSurfaces && stemsTokens;
+  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
+  const stripPossessives = language.tokenizer?.stripPossessive ?? false;
+  let position = 0;
+  for (const part of rawParts) {
+    const candidate = stripPossessives ? stripPossessive(part) : part;
+    if (candidate.length < minLength) {
+      position++;
+      continue;
+    }
+    if (stopWords.has(candidate)) {
+      position++;
+      continue;
+    }
+    const processed = transformToken(candidate, language, stem, effectiveDiacritics);
+    if (processed.length > 0) {
+      if (wantSurfaces) {
+        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
+        yield { token: processed, position, surface: surface === processed ? void 0 : surface };
+      } else {
+        yield { token: processed, position };
+      }
+    }
+    position++;
+  }
+}
+
+// src/schema/constants.ts
+var MAX_NESTING_DEPTH = 4;
+var MAX_DOCUMENT_NESTING_DEPTH = 32;
+
+// src/schema/validator/shared.ts
+var SORTABLE_TEXT_FIELD_TYPE = "string:sortable";
+var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  SORTABLE_TEXT_FIELD_TYPE,
+  "number",
+  "boolean",
+  "enum",
+  "geopoint",
+  "string[]",
+  "number[]",
+  "boolean[]",
+  "enum[]"
+]);
+function isTextFieldType(fieldType) {
+  return fieldType === "string" || fieldType === SORTABLE_TEXT_FIELD_TYPE;
+}
+var VECTOR_PATTERN = /^vector\[(\d+)]$/;
+var FIELD_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+var RESERVED_ROOT_FIELDS = /* @__PURE__ */ new Set(["id"]);
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/schema/validator/schema.ts
+function validateSchemaFields(schema, depth, prefix) {
+  if (depth > MAX_NESTING_DEPTH) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_DEPTH_EXCEEDED,
+      `Schema nesting exceeds the maximum depth of ${MAX_NESTING_DEPTH} at "${prefix}"`,
+      { path: prefix, maxDepth: MAX_NESTING_DEPTH }
+    );
+  }
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    if (PROTOTYPE_POLLUTION_KEYS.has(field)) {
+      throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field name "${field}" is not allowed in a schema`, {
+        field,
+        path
+      });
+    }
+    if (!FIELD_NAME_PATTERN.test(field)) {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field name "${field}" contains characters that are not allowed; use letters, digits, and underscores only`,
+        { field, path }
+      );
+    }
+    if (depth === 1 && RESERVED_ROOT_FIELDS.has(field)) {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${field}" is reserved and cannot be defined in a schema`,
+        { field, path }
+      );
+    }
+    if (isPlainObject(type)) {
+      validateSchemaFields(type, depth + 1, path);
+      continue;
+    }
+    if (typeof type !== "string") {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${path}" has an invalid type definition: ${String(type)}`,
+        {
+          field: path,
+          type: String(type)
+        }
+      );
+    }
+    if (SCALAR_FIELD_TYPES.has(type)) continue;
+    const vectorMatch = VECTOR_PATTERN.exec(type);
+    if (vectorMatch) {
+      const dimension = Number.parseInt(vectorMatch[1], 10);
+      if (dimension <= 0) {
+        throw new NarsilError(
+          ErrorCodes.SCHEMA_INVALID_VECTOR_DIMENSION,
+          `Vector field "${path}" must have a positive dimension, got ${dimension}`,
+          { field: path, dimension }
+        );
+      }
+      continue;
+    }
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field "${path}" has an unsupported type: "${type}"`, {
+      field: path,
+      type
+    });
+  }
+}
+function validateSchema(schema) {
+  if (!isPlainObject(schema)) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must be a plain object", {
+      received: typeof schema
+    });
+  }
+  if (Object.keys(schema).length === 0) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
+  }
+  validateSchemaFields(schema, 1, "");
+}
+function flattenRecursive(schema, prefix, result) {
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    if (isPlainObject(type)) {
+      flattenRecursive(type, path, result);
+    } else {
+      result[path] = type;
+    }
+  }
+}
+function flattenSchema(schema) {
+  const result = {};
+  flattenRecursive(schema, "", result);
+  return result;
+}
+function extractVectorFieldsFromSchema(schema) {
+  const flat = flattenSchema(schema);
+  const result = /* @__PURE__ */ new Map();
+  for (const [fieldPath, fieldType] of Object.entries(flat)) {
+    const match = VECTOR_PATTERN.exec(fieldType);
+    if (match) {
+      result.set(fieldPath, Number.parseInt(match[1], 10));
+    }
+  }
+  return result;
+}
+
+// src/schema/validator/field-values.ts
+function validateGeopoint(path, value) {
+  if (!isPlainObject(value)) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" expected a geopoint object with lat and lon`,
+      {
+        field: path,
+        received: Array.isArray(value) ? "array" : typeof value
+      }
+    );
+  }
+  if (typeof value.lat !== "number" || typeof value.lon !== "number" || Number.isNaN(value.lat) || Number.isNaN(value.lon)) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_GEOPOINT, `Field "${path}" geopoint requires numeric lat and lon`, {
+      field: path,
+      lat: Number.isNaN(value.lat) ? "NaN" : typeof value.lat,
+      lon: Number.isNaN(value.lon) ? "NaN" : typeof value.lon
+    });
+  }
+  if (value.lat < -90 || value.lat > 90) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" geopoint lat must be between -90 and 90`,
+      {
+        field: path,
+        lat: value.lat
+      }
+    );
+  }
+  if (value.lon < -180 || value.lon > 180) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" geopoint lon must be between -180 and 180`,
+      {
+        field: path,
+        lon: value.lon
+      }
+    );
+  }
+}
+function validateVector(path, value, expectedDimension) {
+  const isArray = Array.isArray(value);
+  const isFloat32 = value instanceof Float32Array;
+  if (!isArray && !isFloat32) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Field "${path}" expected a vector (Array or Float32Array)`,
+      { field: path, received: typeof value }
+    );
+  }
+  const arr = value;
+  if (arr.length !== expectedDimension) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Field "${path}" expected vector of dimension ${expectedDimension}, got ${arr.length}`,
+      { field: path, expected: expectedDimension, received: arr.length }
+    );
+  }
+  for (let i = 0; i < arr.length; i++) {
+    if (typeof arr[i] !== "number" || Number.isNaN(arr[i])) {
+      throw new NarsilError(
+        ErrorCodes.DOC_VALIDATION_FAILED,
+        `Field "${path}" vector element at index ${i} is not a valid number`,
+        { field: path, index: i, value: arr[i] }
+      );
+    }
+  }
+}
+function validateTypedArray(path, value, elementType) {
+  if (!Array.isArray(value)) {
+    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an array`, {
+      field: path,
+      received: typeof value
+    });
+  }
+  for (let i = 0; i < value.length; i++) {
+    const el = value[i];
+    if (typeof el !== elementType) {
+      throw new NarsilError(
+        ErrorCodes.DOC_VALIDATION_FAILED,
+        `Field "${path}" array element at index ${i} expected ${elementType}, got ${typeof el}`,
+        { field: path, index: i, expected: elementType, received: typeof el }
+      );
+    }
+    if (elementType === "number" && Number.isNaN(el)) {
+      throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" array element at index ${i} is NaN`, {
+        field: path,
+        index: i
+      });
+    }
+  }
+}
+function validateFieldValue(path, value, type) {
+  switch (type) {
+    case "string":
+    case SORTABLE_TEXT_FIELD_TYPE:
+      if (typeof value !== "string") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected string, got ${typeof value}`,
+          {
+            field: path,
+            expected: "string",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected a valid number`, {
+          field: path,
+          expected: "number",
+          received: Number.isNaN(value) ? "NaN" : typeof value
+        });
+      }
+      return;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected boolean, got ${typeof value}`,
+          {
+            field: path,
+            expected: "boolean",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "enum":
+      if (typeof value !== "string") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected enum (string), got ${typeof value}`,
+          {
+            field: path,
+            expected: "enum",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "geopoint":
+      validateGeopoint(path, value);
+      return;
+    case "string[]":
+      validateTypedArray(path, value, "string");
+      return;
+    case "number[]":
+      validateTypedArray(path, value, "number");
+      return;
+    case "boolean[]":
+      validateTypedArray(path, value, "boolean");
+      return;
+    case "enum[]":
+      validateTypedArray(path, value, "string");
+      return;
+    default: {
+      const vectorMatch = VECTOR_PATTERN.exec(type);
+      if (vectorMatch) {
+        validateVector(path, value, Number.parseInt(vectorMatch[1], 10));
+      }
+    }
+  }
+}
+
+// src/schema/validator/storable.ts
+var RESERVED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function reject(path, reason) {
+  throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path === "" ? "(document)" : path}" ${reason}`, {
+    field: path
+  });
+}
+function isPlainObject2(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function walkStorable(value, path, depth, ancestors, skip) {
+  if (value === null || value === void 0) return;
+  const kind = typeof value;
+  if (kind === "string" || kind === "boolean") return;
+  if (kind === "number") return;
+  if (kind === "bigint" || kind === "symbol" || kind === "function") {
+    reject(path, `holds a ${kind}, which cannot be stored or recovered`);
+  }
+  const container = value;
+  if (container instanceof Date || container instanceof Uint8Array) return;
+  const isArray = Array.isArray(container);
+  if (!isArray && !isPlainObject2(container)) {
+    reject(
+      path,
+      "holds a value that does not survive storage; use plain objects, arrays, strings, numbers, booleans, dates, or Uint8Array bytes"
+    );
+  }
+  if (depth >= MAX_DOCUMENT_NESTING_DEPTH) {
+    reject(path, `nests deeper than ${MAX_DOCUMENT_NESTING_DEPTH} levels`);
+  }
+  if (ancestors.has(container)) {
+    reject(path, "refers back to one of its own ancestors");
+  }
+  ancestors.add(container);
+  if (isArray) {
+    const items = container;
+    for (let i = 0; i < items.length; i++) {
+      walkStorable(items[i], `${path}[${i}]`, depth + 1, ancestors, skip);
+    }
+  } else {
+    const record = container;
+    for (const key of Object.keys(record)) {
+      const keyPath = path === "" ? key : `${path}.${key}`;
+      if (RESERVED_OBJECT_KEYS.has(key)) {
+        reject(keyPath, "uses a reserved object key");
+      }
+      if (skip.has(keyPath)) continue;
+      walkStorable(record[key], keyPath, depth + 1, ancestors, skip);
+    }
+  }
+  ancestors.delete(container);
+}
+function assertStorableDocument(document, skipFieldPaths) {
+  walkStorable(document, "", 0, /* @__PURE__ */ new Set(), skipFieldPaths ?? /* @__PURE__ */ new Set());
+}
+
+// src/schema/validator/document.ts
+var vectorPathCache = /* @__PURE__ */ new WeakMap();
+function vectorFieldPaths(schema) {
+  let paths = vectorPathCache.get(schema);
+  if (paths !== void 0) return paths;
+  paths = /* @__PURE__ */ new Set();
+  const collect = (level, prefix) => {
+    for (const [field, type] of Object.entries(level)) {
+      const path = prefix === "" ? field : `${prefix}.${field}`;
+      if (typeof type === "string" && VECTOR_PATTERN.test(type)) {
+        paths?.add(path);
+      } else if (isPlainObject(type)) {
+        collect(type, path);
+      }
+    }
+  };
+  collect(schema, "");
+  vectorPathCache.set(schema, paths);
+  return paths;
+}
+function validateDocumentFields(doc, schema, prefix) {
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    const value = doc[field];
+    if (value === void 0 || value === null) continue;
+    if (isPlainObject(type)) {
+      if (!isPlainObject(value)) {
+        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an object`, {
+          field: path,
+          received: Array.isArray(value) ? "array" : typeof value
+        });
+      }
+      validateDocumentFields(value, type, path);
+      continue;
+    }
+    validateFieldValue(path, value, type);
+  }
+}
+function validateDocument(document, schema) {
+  if (!isPlainObject(document)) {
+    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document must be a plain object", {
+      received: typeof document
+    });
+  }
+  assertStorableDocument(document, vectorFieldPaths(schema));
+  validateDocumentFields(document, schema, "");
+}
+function collectExtraFields(doc, schema, prefix, extras) {
+  for (const key of Object.keys(doc)) {
+    if (key === "id") continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!(key in schema)) {
+      extras.push(path);
+      continue;
+    }
+    const schemaType = schema[key];
+    if (isPlainObject(schemaType) && isPlainObject(doc[key])) {
+      collectExtraFields(doc[key], schemaType, path, extras);
+    }
+  }
+}
+function validateDocumentStrict(document, schema) {
+  const extras = [];
+  collectExtraFields(document, schema, "", extras);
+  if (extras.length > 0) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Document contains fields not defined in schema: ${extras.join(", ")}`,
+      { extraFields: extras }
+    );
+  }
+}
+function resolveNestedValue(document, path) {
+  if (!path.includes(".")) return document[path];
+  const segments = path.split(".");
+  let current = document;
+  for (const segment of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function validateRequiredFields(document, required) {
+  if (required.length === 0) return;
+  for (const field of required) {
+    const value = resolveNestedValue(document, field);
+    if (value === void 0 || value === null) {
+      throw new NarsilError(ErrorCodes.DOC_MISSING_REQUIRED_FIELD, `Document is missing required field "${field}"`, {
+        field
+      });
+    }
+  }
+}
+
+// src/schema/validator/vector-promotion.ts
+function fail(message, details) {
+  throw new NarsilError(ErrorCodes.CONFIG_INVALID, message, details);
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value >= 1;
+}
+function validateVectorPromotion(config) {
+  if (config === void 0) return;
+  if (config.threshold !== void 0 && !isPositiveInteger(config.threshold)) {
+    fail("vectorPromotion.threshold must be a positive integer", { threshold: config.threshold });
+  }
+  const quantization = config.quantization;
+  if (quantization !== void 0 && quantization !== "sq8" && quantization !== "none") {
+    fail("vectorPromotion.quantization must be 'sq8' or 'none'", { quantization });
+  }
+  const hnsw = config.hnswConfig;
+  if (hnsw === void 0) return;
+  if (hnsw.m !== void 0 && (!isPositiveInteger(hnsw.m) || hnsw.m > MAX_M)) {
+    fail(`vectorPromotion.hnswConfig.m must be a positive integer no greater than ${MAX_M}`, { m: hnsw.m });
+  }
+  if (hnsw.efConstruction !== void 0 && !isPositiveInteger(hnsw.efConstruction)) {
+    fail("vectorPromotion.hnswConfig.efConstruction must be a positive integer", {
+      efConstruction: hnsw.efConstruction
+    });
+  }
+  const metric = hnsw.metric;
+  if (metric !== void 0 && metric !== "cosine" && metric !== "dotProduct" && metric !== "euclidean") {
+    fail("vectorPromotion.hnswConfig.metric must be 'cosine', 'dotProduct', or 'euclidean'", { metric });
+  }
+}
+
+// src/partitioning/distributed-scoring.ts
+function analysedQueryTokens(term, language, analysis) {
+  const { tokens } = tokenize(term, language, {
+    stem: true,
+    removeStopWords: true,
+    customTokenizer: analysis.customTokenizer,
+    stopWordOverride: analysis.stopWords
+  });
+  const unique = /* @__PURE__ */ new Set();
+  for (const { token } of tokens) {
+    unique.add(token);
+  }
+  return unique;
+}
+function copyNumericRecord(source) {
+  const copy = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      copy[key] = value;
+    }
+  }
+  return copy;
+}
+function sanitizeGlobalStats(stats) {
+  return {
+    totalDocuments: typeof stats.totalDocuments === "number" && Number.isFinite(stats.totalDocuments) ? stats.totalDocuments : 0,
+    docFrequencies: copyNumericRecord(stats.docFrequencies),
+    totalFieldLengths: copyNumericRecord(stats.totalFieldLengths),
+    averageFieldLengths: copyNumericRecord(stats.averageFieldLengths)
+  };
+}
+function pruneStatsToQueryTerms(stats, term, language, analysis) {
+  const docFrequencies = /* @__PURE__ */ Object.create(null);
+  for (const token of analysedQueryTokens(term, language, analysis)) {
+    if (Object.hasOwn(stats.docFrequencies, token)) {
+      docFrequencies[token] = stats.docFrequencies[token];
+    }
+  }
+  return {
+    totalDocuments: stats.totalDocuments,
+    docFrequencies,
+    totalFieldLengths: stats.totalFieldLengths,
+    averageFieldLengths: stats.averageFieldLengths
+  };
+}
+function collectQueryTermStats(manager, term, language, analysis, partitionIds) {
+  const queryTokens = analysedQueryTokens(term, language, analysis);
+  let totalDocuments = 0;
+  const docFrequencies = /* @__PURE__ */ Object.create(null);
+  const totalFieldLengths = /* @__PURE__ */ Object.create(null);
+  const statsPartitions = partitionIds === void 0 ? manager.getAllPartitions() : partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
+  for (const partition of statsPartitions) {
+    const stats = partition.stats;
+    totalDocuments += stats.totalDocuments;
+    for (const [field, length] of Object.entries(stats.totalFieldLengths)) {
+      totalFieldLengths[field] = (totalFieldLengths[field] ?? 0) + length;
+    }
+    for (const token of queryTokens) {
+      if (Object.hasOwn(stats.docFrequencies, token)) {
+        docFrequencies[token] = (docFrequencies[token] ?? 0) + stats.docFrequencies[token];
+      }
+    }
+  }
+  const averageFieldLengths = /* @__PURE__ */ Object.create(null);
+  if (totalDocuments > 0) {
+    for (const [field, totalLength] of Object.entries(totalFieldLengths)) {
+      averageFieldLengths[field] = totalLength / totalDocuments;
+    }
+  }
+  return { totalDocuments, docFrequencies, totalFieldLengths, averageFieldLengths };
+}
+function mergePartitionStats(statsArray) {
+  let totalDocuments = 0;
+  const docFrequencies = /* @__PURE__ */ Object.create(null);
+  const totalFieldLengths = /* @__PURE__ */ Object.create(null);
+  for (const stats of statsArray) {
+    totalDocuments += stats.totalDocuments;
+    for (const [term, freq] of Object.entries(stats.docFrequencies)) {
+      docFrequencies[term] = (docFrequencies[term] ?? 0) + freq;
+    }
+    for (const [field, length] of Object.entries(stats.totalFieldLengths)) {
+      totalFieldLengths[field] = (totalFieldLengths[field] ?? 0) + length;
+    }
+  }
+  const averageFieldLengths = /* @__PURE__ */ Object.create(null);
+  if (totalDocuments > 0) {
+    for (const [field, totalLength] of Object.entries(totalFieldLengths)) {
+      averageFieldLengths[field] = totalLength / totalDocuments;
+    }
+  }
+  return {
+    totalDocuments,
+    docFrequencies,
+    totalFieldLengths,
+    averageFieldLengths
+  };
+}
+
+// src/core/partition/scored-merge.ts
+function kWayMerge(arrays) {
+  const nonEmpty = arrays.filter((a) => a.length > 0);
+  if (nonEmpty.length === 0) return [];
+  if (nonEmpty.length === 1) return nonEmpty[0];
+  if (nonEmpty.length <= 4) {
+    return sequentialMerge(nonEmpty);
+  }
+  return heapMerge(nonEmpty);
+}
+function sequentialMerge(arrays) {
+  let merged = arrays[0];
+  for (let i = 1; i < arrays.length; i++) {
+    merged = mergeTwoSorted(merged, arrays[i]);
+  }
+  return merged;
+}
+function mergeTwoSorted(a, b) {
+  const result = new Array(a.length + b.length);
+  let ai = 0;
+  let bi = 0;
+  let ri = 0;
+  while (ai < a.length && bi < b.length) {
+    if (a[ai].score > b[bi].score || a[ai].score === b[bi].score && compareCodePoints(a[ai].docId, b[bi].docId) <= 0) {
+      result[ri++] = a[ai++];
+    } else {
+      result[ri++] = b[bi++];
+    }
+  }
+  while (ai < a.length) {
+    result[ri++] = a[ai++];
+  }
+  while (bi < b.length) {
+    result[ri++] = b[bi++];
+  }
+  return result;
+}
+function heapMerge(arrays) {
+  const heap = [];
+  let totalSize = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    if (arrays[i].length > 0) {
+      totalSize += arrays[i].length;
+      heapPush(heap, {
+        score: arrays[i][0].score,
+        docId: arrays[i][0].docId,
+        partitionIdx: i,
+        resultIdx: 0
+      });
+    }
+  }
+  const result = new Array(totalSize);
+  let writeIdx = 0;
+  while (heap.length > 0) {
+    const top = heapPop(heap);
+    result[writeIdx++] = arrays[top.partitionIdx][top.resultIdx];
+    const nextIdx = top.resultIdx + 1;
+    if (nextIdx < arrays[top.partitionIdx].length) {
+      const nextDoc = arrays[top.partitionIdx][nextIdx];
+      heapPush(heap, {
+        score: nextDoc.score,
+        docId: nextDoc.docId,
+        partitionIdx: top.partitionIdx,
+        resultIdx: nextIdx
+      });
+    }
+  }
+  return result;
+}
+function heapNodeGreater(a, b) {
+  if (a.score !== b.score) return a.score > b.score;
+  return compareCodePoints(a.docId, b.docId) < 0;
+}
+function heapPush(heap, node) {
+  heap.push(node);
+  let idx = heap.length - 1;
+  while (idx > 0) {
+    const parentIdx = idx - 1 >> 1;
+    if (heapNodeGreater(heap[idx], heap[parentIdx])) {
+      const tmp = heap[idx];
+      heap[idx] = heap[parentIdx];
+      heap[parentIdx] = tmp;
+      idx = parentIdx;
+    } else {
+      break;
+    }
+  }
+}
+function heapPop(heap) {
+  const top = heap[0];
+  const last = heap.pop();
+  if (heap.length > 0) {
+    heap[0] = last;
+    let idx = 0;
+    while (true) {
+      const left = 2 * idx + 1;
+      const right = 2 * idx + 2;
+      let largest = idx;
+      if (left < heap.length && heapNodeGreater(heap[left], heap[largest])) {
+        largest = left;
+      }
+      if (right < heap.length && heapNodeGreater(heap[right], heap[largest])) {
+        largest = right;
+      }
+      if (largest !== idx) {
+        const tmp = heap[idx];
+        heap[idx] = heap[largest];
+        heap[largest] = tmp;
+        idx = largest;
+      } else {
+        break;
+      }
+    }
+  }
+  return top;
+}
+
+// src/search/facets.ts
+function mergeFacets(partitionFacets) {
+  const merged = /* @__PURE__ */ new Map();
+  const bounds = /* @__PURE__ */ new Map();
+  for (const partition of partitionFacets) {
+    for (const [field, facetResult] of Object.entries(partition)) {
+      let fieldMap = merged.get(field);
+      if (!fieldMap) {
+        fieldMap = /* @__PURE__ */ new Map();
+        merged.set(field, fieldMap);
+      }
+      bounds.set(field, (bounds.get(field) ?? 0) + facetResult.errorBound);
+      for (const [value, count] of Object.entries(facetResult.values)) {
+        fieldMap.set(value, (fieldMap.get(value) ?? 0) + count);
+      }
+    }
+  }
+  const result = {};
+  for (const [field, valueMap] of merged) {
+    const values = {};
+    for (const [value, count] of valueMap) {
+      values[value] = count;
+    }
+    result[field] = { values, count: valueMap.size, errorBound: bounds.get(field) ?? 0 };
+  }
+  return result;
+}
+
+// src/core/bitset.ts
+function createBitSet(capacity) {
+  return new Uint32Array(capacity + 31 >>> 5 || 1);
+}
+function bitsetSet(bs, index) {
+  const word = index >>> 5;
+  if (word < bs.length) {
+    bs[word] |= 1 << (index & 31);
+  }
+}
+function bitsetHas(bs, index) {
+  const word = index >>> 5;
+  if (word >= bs.length) return false;
+  return (bs[word] & 1 << (index & 31)) !== 0;
+}
+function bitsetAnd(a, b) {
+  const len = Math.min(a.length, b.length);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = a[i] & b[i];
+  }
+  return result;
+}
+function bitsetOr(a, b) {
+  const longer = a.length >= b.length ? a : b;
+  const shorter = a.length >= b.length ? b : a;
+  const result = new Uint32Array(longer.length);
+  for (let i = 0; i < shorter.length; i++) {
+    result[i] = longer[i] | shorter[i];
+  }
+  for (let i = shorter.length; i < longer.length; i++) {
+    result[i] = longer[i];
+  }
+  return result;
+}
+function bitsetNot(bs, capacity) {
+  const result = new Uint32Array(bs.length);
+  const fullWords = capacity >>> 5;
+  for (let i = 0; i < fullWords; i++) {
+    result[i] = ~bs[i];
+  }
+  const remainder = capacity & 31;
+  if (remainder > 0 && fullWords < bs.length) {
+    result[fullWords] = ~bs[fullWords] & (1 << remainder) - 1;
+  }
+  return result;
+}
+function bitsetIsEmpty(bs) {
+  for (let i = 0; i < bs.length; i++) {
+    if (bs[i] !== 0) return false;
+  }
+  return true;
+}
+function bitsetFromSet(set, capacity) {
+  const bs = createBitSet(capacity);
+  for (const id of set) {
+    bs[id >>> 5] |= 1 << (id & 31);
+  }
+  return bs;
+}
+
+// src/core/fuzzy.ts
+function boundedLevenshtein(a, b, tolerance) {
+  if (tolerance < 0) return { distance: -1, withinTolerance: false };
+  if (a === b) return { distance: 0, withinTolerance: true };
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) {
+    return n <= tolerance ? { distance: n, withinTolerance: true } : { distance: n, withinTolerance: false };
+  }
+  if (n === 0) {
+    return m <= tolerance ? { distance: m, withinTolerance: true } : { distance: m, withinTolerance: false };
+  }
+  if (a.startsWith(b)) {
+    const diff2 = m - n;
+    return diff2 <= tolerance ? { distance: diff2, withinTolerance: true } : { distance: diff2, withinTolerance: false };
+  }
+  if (b.startsWith(a)) {
+    return { distance: 0, withinTolerance: true };
+  }
+  const diff = Math.abs(m - n);
+  if (diff > tolerance) return { distance: -1, withinTolerance: false };
+  const matrix = [];
+  for (let i = 0; i <= m; i++) {
+    matrix[i] = [i];
+    for (let j = 1; j <= n; j++) {
+      matrix[i][j] = i === 0 ? j : 0;
+    }
+  }
+  for (let i = 1; i <= m; i++) {
+    let rowMin = Infinity;
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + 1);
+      }
+      rowMin = Math.min(rowMin, matrix[i][j]);
+    }
+    if (rowMin > tolerance) {
+      return { distance: -1, withinTolerance: false };
+    }
+  }
+  const finalDistance = matrix[m][n];
+  return {
+    distance: finalDistance,
+    withinTolerance: finalDistance <= tolerance
+  };
+}
+
+// src/search/cursor-codec.ts
+function encodeCursorText(text) {
+  if (typeof Buffer !== "undefined") return Buffer.from(text, "utf-8").toString("base64");
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function decodeCursorText(encoded) {
+  if (typeof Buffer !== "undefined") return Buffer.from(encoded, "base64").toString("utf-8");
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+
+// src/search/sorting.ts
+function isFieldList(sort) {
+  return Array.isArray(sort);
+}
+function normalizeSort(sort) {
+  if (sort === void 0) return [];
+  if (isFieldList(sort)) {
+    return sort.map((entry) => ({ field: entry.field, direction: entry.direction }));
+  }
+  return Object.entries(sort).map(([field, direction]) => ({ field, direction }));
+}
+function requireSortableFields(sort, schema) {
+  const fields = normalizeSort(sort);
+  if (fields.length === 0) return;
+  const flatSchema = flattenSchema(schema);
+  for (const entry of fields) {
+    if (flatSchema[entry.field] !== "string") continue;
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_FIELD,
+      `A sort names text field "${entry.field}" only where the schema declares it "${SORTABLE_TEXT_FIELD_TYPE}", because ordering text costs far more memory per document than ordering a number`,
+      { field: entry.field, fieldType: "string" }
+    );
+  }
+}
+function readFieldValue(obj, path) {
+  return readSortField(obj, path);
+}
+function readSortValues(document, fields) {
+  if (!document) return fields.map(() => void 0);
+  return fields.map((field) => readFieldValue(document, field));
+}
+function applySorting(hits, sort, sortKeyOf) {
+  const normalized = normalizeSort(sort);
+  if (normalized.length === 0) return hits;
+  const directions = normalized.map((entry) => entry.direction);
+  const keyCache = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    keyCache.set(hit.id, sortKeyOf(hit.id));
+  }
+  const sorted = hits.slice();
+  sorted.sort(
+    (a, b) => compareComparableKeys(keyCache.get(a.id) ?? [], keyCache.get(b.id) ?? [], directions) || compareCodePoints(a.id, b.id)
+  );
+  return sorted;
+}
+
+// src/search/cursor.ts
+var CURSOR_VERSION = 3;
+function invalidCursor(cursor, reason) {
+  const shown = cursor.length > 100 ? `${cursor.slice(0, 100)}...` : cursor;
+  return new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, `Failed to decode cursor: ${reason}`, { cursor: shown });
+}
+function exceedsCodePoints(value, maximum) {
+  if (value.length <= maximum) return false;
+  let counted = 0;
+  let i = 0;
+  while (i < value.length) {
+    const unit = value.charCodeAt(i);
+    if (unit >= 55296 && unit < 56320 && i + 1 < value.length) {
+      const low = value.charCodeAt(i + 1);
+      if (low >= 56320 && low < 57344) i++;
+    }
+    i++;
+    counted++;
+    if (counted > maximum) return true;
+  }
+  return false;
+}
+function sortSignatureOf(sort) {
+  const fields = normalizeSort(sort);
+  if (fields.length === 0) return null;
+  if (fields.length > MAX_SORT_FIELDS) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_FIELD,
+      `A sort names at most ${MAX_SORT_FIELDS} fields, because the paging cursor carries one value per field`,
+      { count: fields.length, limit: MAX_SORT_FIELDS }
+    );
+  }
+  for (const entry of fields) {
+    if (entry.field.length > MAX_SORT_FIELD_NAME_LENGTH) {
+      throw new NarsilError(
+        ErrorCodes.SEARCH_INVALID_FIELD,
+        `A sort field name holds at most ${MAX_SORT_FIELD_NAME_LENGTH} characters, because the paging cursor carries the sort with every page`,
+        { field: entry.field.slice(0, 64), length: entry.field.length, limit: MAX_SORT_FIELD_NAME_LENGTH }
+      );
+    }
+  }
+  return JSON.stringify(fields.map((entry) => [entry.field, entry.direction]));
+}
+function encodePageCursor(cursor) {
+  const payload = { v: CURSOR_VERSION, a: cursor.anchor };
+  if (cursor.sortKey !== null && cursor.sortSignature !== null) {
+    payload.k = cursor.sortKey.map(toComparableSortValue);
+    payload.o = cursor.sortSignature;
+  } else if (cursor.score !== null) {
+    payload.s = cursor.score;
+  }
+  payload.q = cursor.binding;
+  return encodeCursorText(JSON.stringify(payload));
+}
+function decodeSortKey(value, cursor) {
+  if (!Array.isArray(value)) throw invalidCursor(cursor, '"k" must be an array');
+  if (value.length > MAX_SORT_FIELDS) throw invalidCursor(cursor, '"k" carries too many sort values');
+  const key = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry === "boolean") {
+      key.push(entry);
+      continue;
+    }
+    if (typeof entry === "number") {
+      if (!Number.isFinite(entry)) throw invalidCursor(cursor, '"k" holds a number that is not finite');
+      key.push(entry);
+      continue;
+    }
+    if (typeof entry === "string") {
+      if (exceedsCodePoints(entry, SORT_VALUE_MAX_CODE_POINTS)) {
+        throw invalidCursor(cursor, '"k" holds an oversized sort value');
+      }
+      key.push(entry);
+      continue;
+    }
+    throw invalidCursor(cursor, '"k" accepts a string, a finite number, a boolean, or null');
+  }
+  return key;
+}
+function decodePageCursor(cursor) {
+  if (cursor.length > MAX_CURSOR_LENGTH) throw invalidCursor(cursor, "the cursor is too long");
+  let json;
+  try {
+    json = decodeCursorText(cursor);
+  } catch {
+    throw invalidCursor(cursor, "invalid base64 encoding");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw invalidCursor(cursor, "invalid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw invalidCursor(cursor, "expected an object");
+  }
+  const { v, a, s, k, o, q } = parsed;
+  if (v !== CURSOR_VERSION) throw invalidCursor(cursor, `unsupported cursor version ${String(v)}`);
+  if (typeof q !== "string" || !/^[0-9a-f]{8}$/.test(q)) {
+    throw invalidCursor(cursor, '"q" must be 8 lowercase hex digits');
+  }
+  if (typeof a !== "string" || a.length === 0) throw invalidCursor(cursor, '"a" must be a non-empty string');
+  if (exceedsCodePoints(a, MAX_CURSOR_ANCHOR_CODE_POINTS)) {
+    throw invalidCursor(cursor, '"a" is too long to be a document id');
+  }
+  if (s !== void 0 && (typeof s !== "number" || !Number.isFinite(s))) {
+    throw invalidCursor(cursor, '"s" must be a finite number');
+  }
+  if (s !== void 0 && k !== void 0) throw invalidCursor(cursor, 'a cursor carries "s" or "k", never both');
+  const sortKey = k === void 0 ? null : decodeSortKey(k, cursor);
+  if (o !== void 0 && typeof o !== "string") throw invalidCursor(cursor, '"o" must be a string');
+  if (sortKey === null !== (o === void 0)) {
+    throw invalidCursor(cursor, '"k" and "o" have to arrive together');
+  }
+  return {
+    anchor: a,
+    score: typeof s === "number" ? s : null,
+    sortKey,
+    sortSignature: typeof o === "string" ? o : null,
+    binding: q
+  };
+}
+function requireMatchingCursor(cursor, encoded, signature, scoreAnchored, binding) {
+  if (cursor.binding !== binding) {
+    throw invalidCursor(encoded, "the cursor belongs to a different query");
+  }
+  if (signature !== null) {
+    if (cursor.sortSignature !== signature) {
+      throw invalidCursor(encoded, "the cursor belongs to a different sort order");
+    }
+    return;
+  }
+  if (cursor.sortSignature !== null) {
+    throw invalidCursor(encoded, "the cursor belongs to a sorted request");
+  }
+  if (scoreAnchored && cursor.score === null) {
+    throw invalidCursor(encoded, "the cursor carries no score to seek from");
+  }
+  if (!scoreAnchored && cursor.score !== null) {
+    throw invalidCursor(encoded, "the cursor belongs to a search rather than a listing");
+  }
+}
+
+// src/search/pagination.ts
+function clampRowCount(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function requireWithinResultWindow(limit, offset) {
+  const depth = offset + limit;
+  if (depth <= RESULT_WINDOW) return;
+  throw new NarsilError(
+    ErrorCodes.SEARCH_RESULT_WINDOW_EXCEEDED,
+    `A request reaches the first ${RESULT_WINDOW} results, and offset + limit is ${depth}. Page past that with the cursor each result carries`,
+    { limit, offset, window: RESULT_WINDOW }
+  );
+}
+function lastOrganicResult(sliced, pinnedIds) {
+  for (let i = sliced.length - 1; i >= 0; i--) {
+    if (pinnedIds === void 0 || !pinnedIds.has(sliced[i].id)) return sliced[i];
+  }
+  return void 0;
+}
+function ordersAfterAnchor(result, anchor, sort) {
+  if (sort !== void 0 && anchor.sortKey !== null) {
+    const comparison = compareSortValues(sort.sortKeyOf(result.id), anchor.sortKey, sort.directions) || compareCodePoints(result.id, anchor.anchor);
+    return comparison > 0;
+  }
+  if (anchor.score === null) return true;
+  if (result.score === void 0) return true;
+  if (result.score < anchor.score) return true;
+  return result.score === anchor.score && compareCodePoints(result.id, anchor.anchor) > 0;
+}
+function applyPagination(results, limit, offset, binding, cursor, sort, pinnedIds) {
+  const decoded = cursor ? decodePageCursor(cursor) : null;
+  if (decoded !== null && cursor !== void 0) {
+    requireMatchingCursor(decoded, cursor, sort?.signature ?? null, true, binding);
+  }
+  if (limit <= 0) {
+    return { paginated: [] };
+  }
+  let startIndex = 0;
+  if (decoded !== null) {
+    startIndex = results.length;
+    for (let i = 0; i < results.length; i++) {
+      if (ordersAfterAnchor(results[i], decoded, sort)) {
+        startIndex = i;
+        break;
+      }
+    }
+  }
+  const afterOffset = startIndex + offset;
+  const sliced = results.slice(afterOffset, afterOffset + limit);
+  let nextCursor;
+  const hasMore = afterOffset + limit < results.length;
+  const lastResult = lastOrganicResult(sliced, pinnedIds);
+  if (hasMore && lastResult !== void 0) {
+    nextCursor = sort !== void 0 ? encodePageCursor({
+      anchor: lastResult.id,
+      score: null,
+      sortKey: sort.sortKeyOf(lastResult.id).map(toComparableSortValue),
+      sortSignature: sort.signature,
+      binding
+    }) : encodePageCursor({
+      anchor: lastResult.id,
+      score: lastResult.score ?? null,
+      sortKey: null,
+      sortSignature: null,
+      binding
+    });
+  }
+  return { paginated: sliced, nextCursor };
+}
+
+// src/search/fulltext.ts
+function resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken) {
+  const term = params.term;
+  if (term === void 0) return void 0;
+  const unstemmed = tokenize(term, language, {
+    stem: false,
+    removeStopWords: true,
+    customTokenizer: options?.customTokenizer,
+    stopWordOverride: options?.stopWords
+  });
+  let surfacePrefix;
+  for (const t of unstemmed.tokens) {
+    if (t.position === lastToken.position) {
+      surfacePrefix = t.token;
+      break;
+    }
+  }
+  if (surfacePrefix === void 0 || surfacePrefix.length === 0) return void 0;
+  const expansions = partition.expandTermPrefix(surfacePrefix, lastToken.token, PREFIX_MAX_EXPANSIONS);
+  const terms = [];
+  for (const expanded of expansions) {
+    if (expanded !== lastToken.token) terms.push(expanded);
+  }
+  for (const qt of queryTokens) {
+    if (qt.token === lastToken.token) {
+      return { token: qt.token, terms };
+    }
+  }
+  return void 0;
+}
+function prepareFulltextQuery(partition, params, language, schema, options) {
+  if (!params.term || params.term.trim().length === 0) return null;
+  if (params.fields && params.fields.length === 0) return null;
+  const flatSchema = flattenSchema(schema);
+  if (params.fields) {
+    validateSearchFields(params.fields, flatSchema);
+  }
+  const queryTokenResult = tokenize(params.term, language, {
+    stem: true,
+    removeStopWords: true,
+    customTokenizer: options?.customTokenizer,
+    stopWordOverride: options?.stopWords
+  });
+  if (queryTokenResult.tokens.length === 0) return null;
+  const queryTokens = deduplicateTokens(queryTokenResult.tokens);
+  let prefixExpansion;
+  if (params.prefix === true && params.exact !== true) {
+    const lastToken = queryTokenResult.tokens[queryTokenResult.tokens.length - 1];
+    prefixExpansion = resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken);
+  }
+  let filterBitset;
+  if (params.filters) {
+    filterBitset = partition.applyFiltersBitset(params.filters, schema);
+    if (bitsetIsEmpty(filterBitset)) return null;
+  }
+  return { queryTokens, prefixExpansion, filterBitset };
+}
+function fulltextMatches(partition, params, language, schema, options) {
+  const prepared = prepareFulltextQuery(partition, params, language, schema, options);
+  if (prepared === null) return null;
+  return partition.searchFulltextMatches({
+    queryTokens: prepared.queryTokens,
+    prefixExpansion: prepared.prefixExpansion,
+    fields: params.fields,
+    tolerance: params.tolerance ?? 0,
+    prefixLength: params.prefixLength ?? 2,
+    exact: params.exact ?? false,
+    filterBitset: prepared.filterBitset
+  });
+}
+function fulltextSearch(partition, params, language, schema, options) {
+  const prepared = prepareFulltextQuery(partition, params, language, schema, options);
+  if (prepared === null) {
+    return { scored: [], totalMatched: 0 };
+  }
+  const { queryTokens, prefixExpansion, filterBitset } = prepared;
+  const needsAllResults = params.minScore !== void 0 || params.termMatch !== void 0 && params.termMatch !== "any" || params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
+  const maxResults = needsAllResults ? void 0 : clampRowCount(params.limit, DEFAULT_PAGE_SIZE) + clampRowCount(params.offset, 0) + 1;
+  const collectMatchedSet = params.facets !== void 0 && !needsAllResults ? "ordinals" : void 0;
+  const collectComponents = params.includeScoreComponents === true || params.termMatch !== void 0 && params.termMatch !== "any";
+  const rawResult = partition.searchFulltext({
+    queryTokens,
+    prefixExpansion,
+    fields: params.fields,
+    boost: params.boost,
+    tolerance: params.tolerance ?? 0,
+    prefixLength: params.prefixLength ?? 2,
+    exact: params.exact ?? false,
+    bm25Params: options?.bm25Params,
+    globalStats: options?.globalStats,
+    maxResults,
+    termMatch: params.termMatch,
+    filterBitset,
+    collectComponents,
+    collectMatchedSet
+  });
+  let scored = rawResult.scored;
+  const termMatch = params.termMatch ?? "any";
+  if (termMatch !== "any") {
+    scored = filterByTermCoverage(
+      scored,
+      queryTokens,
+      termMatch,
+      params.tolerance ?? 0,
+      params.exact ?? false,
+      prefixExpansion
+    );
+  }
+  if (params.minScore !== void 0 && params.minScore > 0) {
+    const threshold = params.minScore;
+    scored = scored.filter((doc) => doc.score >= threshold);
+  }
+  const totalMatched = needsAllResults ? scored.length : rawResult.totalMatched;
+  if (params.facets === void 0) {
+    return { scored, totalMatched };
+  }
+  if (needsAllResults) {
+    return { scored, totalMatched, matchedIds: scored.map((doc) => doc.docId) };
+  }
+  return { scored, totalMatched, matchedOrdinalBitset: rawResult.matchedOrdinalBitset };
+}
+function validateSearchFields(fields, flatSchema) {
+  for (const field of fields) {
+    const fieldType = flatSchema[field];
+    if (!fieldType) {
+      throw new NarsilError(ErrorCodes.SEARCH_INVALID_FIELD, `Field "${field}" does not exist in the schema`, { field });
+    }
+    if (!isTextFieldType(fieldType) && fieldType !== "string[]") {
+      throw new NarsilError(
+        ErrorCodes.SEARCH_INVALID_FIELD,
+        `Field "${field}" has type "${fieldType}" which cannot be used for full-text search`,
+        { field, fieldType }
+      );
+    }
+  }
+}
+function deduplicateTokens(tokens) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const t of tokens) {
+    if (!seen.has(t.token)) {
+      seen.add(t.token);
+      result.push(t);
+    }
+  }
+  return result;
+}
+function filterByTermCoverage(scored, queryTokens, policy, tolerance, exact, prefixExpansion) {
+  const requiredCount = policy === "all" ? queryTokens.length : policy;
+  if (requiredCount <= 0) return scored;
+  if (requiredCount > queryTokens.length) return [];
+  const expansionTerms = prefixExpansion ? new Set(prefixExpansion.terms) : void 0;
+  return scored.filter((doc) => {
+    const matched = countDocTermMatches(doc, queryTokens, tolerance, exact, prefixExpansion?.token, expansionTerms);
+    return matched >= requiredCount;
+  });
+}
+function countDocTermMatches(doc, queryTokens, tolerance, exact, prefixToken, expansionTerms) {
+  const indexTokens = Object.keys(doc.idf);
+  if (indexTokens.length === 0) return 0;
+  let count = 0;
+  for (const qt of queryTokens) {
+    if (prefixToken !== void 0 && qt.token === prefixToken) {
+      if (prefixTokenSatisfied(qt.token, indexTokens, expansionTerms)) {
+        count++;
+      }
+      continue;
+    }
+    if (queryTermSatisfied(qt.token, indexTokens, tolerance, exact)) {
+      count++;
+    }
+  }
+  return count;
+}
+function prefixTokenSatisfied(prefixToken, indexTokens, expansionTerms) {
+  for (const indexToken of indexTokens) {
+    if (indexToken === prefixToken) return true;
+    if (expansionTerms?.has(indexToken)) return true;
+  }
+  return false;
+}
+function queryTermSatisfied(queryToken, indexTokens, tolerance, exact) {
+  if (exact || tolerance === 0) {
+    return indexTokens.includes(queryToken);
+  }
+  for (const indexToken of indexTokens) {
+    if (boundedLevenshtein(queryToken, indexToken, tolerance).withinTolerance) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/partitioning/partition-selection.ts
+function partitionsIn(manager, partitionIds) {
+  if (partitionIds === void 0) {
+    return manager.getAllPartitions();
+  }
+  const partitions = [];
+  for (const partitionId of partitionIds) {
+    const partition = manager.partitionAt(partitionId);
+    if (partition !== void 0) {
+      partitions.push(partition);
+    }
+  }
+  return partitions;
+}
+
+// src/partitioning/fan-out.ts
+async function fanOutQuery(manager, params, language, schema, config, searchOptions) {
+  const partitions = partitionsIn(manager, config.partitionIds);
+  if (partitions.length === 0) {
+    return { scored: [], totalMatched: 0 };
+  }
+  let globalStats;
+  const effectiveMode = resolveEffectiveMode(config);
+  if (effectiveMode === "dfs") {
+    if (params.term !== void 0 && params.term.trim().length > 0) {
+      globalStats = collectQueryTermStats(
+        manager,
+        params.term,
+        language,
+        {
+          stopWords: searchOptions?.stopWords,
+          customTokenizer: searchOptions?.customTokenizer
+        },
+        config.partitionIds
+      );
+    }
+  } else if (effectiveMode === "broadcast") {
+    globalStats = config.globalStats;
+  }
+  const options = buildSearchOptions(searchOptions, globalStats);
+  if (partitions.length === 1 && !config.dispatcher) {
+    const result = dispatchSinglePartition(partitions[0], params, language, schema, options);
+    let facets2;
+    if (params.facets) {
+      facets2 = partitions[0].computeFacets(facetMatchSetOf(result), params.facets, schema);
+    }
+    return { scored: result.scored, totalMatched: result.totalMatched, facets: facets2 };
+  }
+  let outcomes;
+  let facets;
+  if (config.dispatcher) {
+    outcomes = await dispatchWithDispatcher(partitions, params, language, schema, options, config.dispatcher);
+    if (params.facets) {
+      facets = collectAndMergeFacets(outcomes, params, schema);
+    }
+  } else {
+    outcomes = [];
+    const partitionFacets = [];
+    for (const partition of partitions) {
+      const result = dispatchSinglePartition(partition, params, language, schema, options);
+      if (params.facets) {
+        partitionFacets.push(partition.computeFacets(facetMatchSetOf(result), params.facets, schema));
+      }
+      outcomes.push({ result, partition });
+    }
+    if (params.facets) {
+      facets = mergeFacets(partitionFacets);
+    }
+  }
+  const allScoredArrays = outcomes.map((o) => o.result.scored);
+  const merged = kWayMerge(allScoredArrays);
+  let totalMatched = 0;
+  for (const outcome of outcomes) {
+    totalMatched += outcome.result.totalMatched;
+  }
+  return { scored: merged, totalMatched, facets };
+}
+function facetMatchSetOf(result) {
+  if (result.matchedOrdinalBitset !== void 0) {
+    return { ordinalBitset: result.matchedOrdinalBitset };
+  }
+  return new Set(result.matchedIds ?? []);
+}
+function resolveEffectiveMode(config) {
+  if (config.scoringMode === "broadcast" && !config.globalStats) {
+    return "dfs";
+  }
+  return config.scoringMode;
+}
+function buildSearchOptions(base, globalStats) {
+  return {
+    ...base,
+    globalStats: globalStats ?? base?.globalStats
+  };
+}
+function dispatchWithDispatcher(partitions, params, language, schema, options, dispatcher) {
+  const promises = partitions.map(
+    (partition) => dispatcher.dispatch(partition, params, language, schema, options).then((result) => ({ result, partition }))
+  );
+  return Promise.all(promises);
+}
+function dispatchSinglePartition(partition, params, language, schema, options) {
+  return fulltextSearch(partition, params, language, schema, options);
+}
+function collectAndMergeFacets(outcomes, params, schema) {
+  const partitionFacets = [];
+  for (const outcome of outcomes) {
+    if (!params.facets) continue;
+    const facetResult = outcome.partition.computeFacets(facetMatchSetOf(outcome.result), params.facets, schema);
+    partitionFacets.push(facetResult);
+  }
+  return mergeFacets(partitionFacets);
+}
+
+// src/partitioning/match-count.ts
+function countsWithoutScores(params) {
+  return params.minScore === void 0 && (params.termMatch === void 0 || params.termMatch === "any");
+}
+function fanOutMatchCount(manager, params, language, schema, options) {
+  let count = 0;
+  for (const partition of partitionsIn(manager, options?.partitionIds)) {
+    const matches = fulltextMatches(partition, params, language, schema, options?.searchOptions);
+    if (matches !== null) count += matches.count;
+  }
+  return count;
+}
+
+// src/core/projection.ts
+function splitPaths(paths) {
+  if (!paths) return [];
+  const split = [];
+  for (const path of paths) {
+    const segments = path.split(".").filter((segment) => segment.length > 0);
+    if (segments.length === 0) continue;
+    if (segments.some((segment) => PROTOTYPE_POLLUTION_KEYS.has(segment))) continue;
+    split.push(segments);
+  }
+  return split;
+}
+function overlaps(a, b) {
+  const shared = Math.min(a.length, b.length);
+  for (let i = 0; i < shared; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function covers(outer, inner) {
+  if (outer.length > inner.length) return false;
+  for (let i = 0; i < outer.length; i++) {
+    if (outer[i] !== inner[i]) return false;
+  }
+  return true;
+}
+function readPath(source, path) {
+  let current = source;
+  for (const segment of path) {
+    if (typeof current !== "object" || current === null || Array.isArray(current))
+      return { found: false, value: void 0 };
+    const record = current;
+    if (!Object.hasOwn(record, segment)) return { found: false, value: void 0 };
+    current = record[segment];
+  }
+  return { found: true, value: current };
+}
+function writePath(target, path, value) {
+  let current = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i];
+    const existing = current[segment];
+    if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+      current = existing;
+      continue;
+    }
+    const created = {};
+    current[segment] = created;
+    current = created;
+  }
+  current[path[path.length - 1]] = value;
+}
+function omitPath(source, path) {
+  const segment = path[0];
+  if (!Object.hasOwn(source, segment)) return source;
+  const copy = { ...source };
+  if (path.length === 1) {
+    delete copy[segment];
+    return copy;
+  }
+  const child = copy[segment];
+  if (typeof child !== "object" || child === null || Array.isArray(child)) return copy;
+  copy[segment] = omitPath(child, path.slice(1));
+  return copy;
+}
+function cloneExcept(value, path, exclude) {
+  const reachesDeeper = exclude.some((excluded) => excluded.length > path.length && covers(path, excluded));
+  if (!reachesDeeper) return structuredClone(value);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return structuredClone(value);
+  const source = value;
+  const kept = {};
+  for (const key of Object.keys(source)) {
+    const childPath = [...path, key];
+    if (exclude.some((excluded) => covers(excluded, childPath))) continue;
+    kept[key] = cloneExcept(source[key], childPath, exclude);
+  }
+  return kept;
+}
+function resolveProjection(projection) {
+  if (projection === void 0 || projection === true) return { kind: "full" };
+  if (projection === false) return { kind: "none" };
+  if (typeof projection !== "object" || projection === null) return { kind: "full" };
+  const askedInclude = Array.isArray(projection.include) && projection.include.length > 0;
+  const askedExclude = Array.isArray(projection.exclude) && projection.exclude.length > 0;
+  if (!askedInclude && !askedExclude) return { kind: "full" };
+  return {
+    kind: "fields",
+    include: askedInclude ? splitPaths(projection.include) : null,
+    exclude: splitPaths(projection.exclude)
+  };
+}
+function projectionKeepsField(projection, fieldPath) {
+  if (projection.kind === "full") return true;
+  if (projection.kind === "none") return false;
+  const path = fieldPath.split(".").filter((segment) => segment.length > 0);
+  if (path.length === 0) return false;
+  if (projection.include && !projection.include.some((included) => overlaps(included, path))) return false;
+  return !projection.exclude.some((excluded) => covers(excluded, path));
+}
+function cloneProjected(document, projection) {
+  if (projection === void 0 || projection.kind === "full") return structuredClone(document);
+  if (projection.kind === "none") return {};
+  if (projection.include === null) return cloneExcept(document, [], projection.exclude);
+  const projected = {};
+  for (const path of projection.include) {
+    if (projection.exclude.some((excluded) => covers(excluded, path))) continue;
+    const { found, value } = readPath(document, path);
+    if (!found) continue;
+    writePath(projected, path, cloneExcept(value, path, projection.exclude));
+  }
+  return projected;
+}
+function applyProjection(document, projection) {
+  if (projection.kind === "full") return document;
+  if (projection.kind === "none") return {};
+  let projected;
+  if (projection.include) {
+    projected = {};
+    for (const path of projection.include) {
+      const { found, value } = readPath(document, path);
+      if (found) writePath(projected, path, value);
+    }
+  } else {
+    projected = document;
+  }
+  for (const path of projection.exclude) {
+    projected = omitPath(projected, path);
+  }
+  return projected;
+}
+
+// src/core/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var encoder = new TextEncoder();
+function fnv1aBytes(bytes) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < bytes.length; i++) {
+    hash ^= bytes[i];
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return hash >>> 0;
+}
+function fnv1a(input) {
+  return fnv1aBytes(encoder.encode(input));
+}
+
+export { MAX_NESTING_DEPTH, VECTOR_PATTERN, applyPagination, applyProjection, applySorting, bitsetAnd, bitsetFromSet, bitsetHas, bitsetNot, bitsetOr, bitsetSet, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, configureNormalizationCache, countsWithoutScores, createBitSet, decodePageCursor, encodePageCursor, extractVectorFieldsFromSchema, fanOutMatchCount, fanOutQuery, flattenSchema, fnv1a, fnv1aBytes, fulltextMatches, getNormalizationCacheSize, isTextFieldType, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, partitionsIn, projectionKeepsField, pruneStatsToQueryTerms, readSortValues, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, sortSignatureOf, tokenize, tokenizeIterator, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion };