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

package/dist/{chunk-EV45L35L.mjs → chunk-BEIK3EOZ.mjs}

@@ -1,489 +1,103 @@
+import { countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, cloneProjected, validateDocument, validateDocumentStrict, projectionKeepsField, fnv1a, VECTOR_PATTERN, extractVectorFieldsFromSchema, boundedLevenshtein, bitsetHas, createBitSet, bitsetSet, isTextFieldType, flattenSchema, tokenize, bitsetFromSet, tokenizeIterator, mergeFacets, bitsetAnd, bitsetOr, bitsetNot, kWayMerge } from './chunk-CMVG2UEF.mjs';
+import { detectRuntime } from './chunk-AV4IJKD2.mjs';
 import { english } from './chunk-TGP5M5R7.mjs';
-import { createScalarQuantizer } from './chunk-4COAUBLJ.mjs';
-import { MAX_M, createVectorStore, createHNSWIndex, createOrdinalFilter, addToOrdinalFilter, removeFromOrdinalFilter, ordinalFilterValues, magnitude, toScore, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, ABSENT_DOCUMENT_RANK } from './chunk-DFZDV5FV.mjs';
-import { compareCodePoints, compareComparableKeys, toComparableSortValue, readSortField, compareSortValues, compareComparableValues, SORT_VALUE_MAX_CODE_POINTS } from './chunk-BFIH7OV5.mjs';
-import { generateId, createRequestId } from './chunk-WTONLDU3.mjs';
-import { NarsilError, ErrorCodes, createNarsilError } from './chunk-P4ELXVJQ.mjs';
+import { createScalarQuantizer, openSharedWorkerCopy } from './chunk-PMBHH44R.mjs';
+import { createVectorStore, createHNSWIndex, createOrdinalFilter, addToOrdinalFilter, removeFromOrdinalFilter, ordinalFilterValues, magnitude, toScore, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, searchOrdinals, WASM_PAGE_BYTES, entryForOrd, toDistance, MAX_WASM_PAGES, ABSENT_DOCUMENT_RANK, HNSW_BUILD_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_SEARCH_TIMEOUT_MS } from './chunk-X6YZO4MQ.mjs';
+import { compareCodePoints, toComparableSortValue, readSortField, compareComparableValues, SORT_VALUE_MAX_CODE_POINTS } from './chunk-2GWVQWGA.mjs';
+import { createRequestId } from './chunk-WYJXSLER.mjs';
+import { NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import { getHeapStatistics } from 'v8';
 import { encode, decode } from '@msgpack/msgpack';
 
-// 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"]);
-var MAX_NESTING_DEPTH = 4;
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// 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));
-      }
-    }
+function readHeapStatistics() {
+  try {
+    const stats = getHeapStatistics();
+    const usedBytes = stats.used_heap_size;
+    const limitBytes = stats.heap_size_limit;
+    if (!Number.isFinite(usedBytes) || !Number.isFinite(limitBytes) || limitBytes <= 0) return null;
+    return { usedBytes, limitBytes };
+  } catch {
+    return null;
   }
 }
 
-// src/schema/validator/storable.ts
-var MAX_DOCUMENT_NESTING_DEPTH = 32;
-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
-  });
+// src/languages/registry.ts
+var languages = /* @__PURE__ */ new Map();
+languages.set("english", english);
+function registerLanguage(module) {
+  languages.set(module.name, module);
 }
-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);
-    }
+function getLanguage(name) {
+  const lang = languages.get(name);
+  if (!lang) {
+    throw new NarsilError(ErrorCodes.LANGUAGE_NOT_SUPPORTED, `Language "${name}" is not registered`, { language: name });
   }
-  ancestors.delete(container);
-}
-function assertStorableDocument(document, skipFieldPaths) {
-  walkStorable(document, "", 0, /* @__PURE__ */ new Set(), skipFieldPaths ?? /* @__PURE__ */ new Set());
+  return lang;
 }
 
-// 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
-    });
+// src/analysis/registry.ts
+var tokenizers = /* @__PURE__ */ new Map();
+var stopWordSets = /* @__PURE__ */ new Map();
+function requireName(name, kind) {
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `A registered ${kind} needs a non-empty name`, { name });
   }
-  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 registerTokenizer(name, tokenizer) {
+  requireName(name, "tokenizer");
+  if (typeof tokenizer?.tokenize !== "function") {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Tokenizer "${name}" needs a tokenize method`, { tokenizer: name });
   }
+  tokenizers.set(name, tokenizer);
 }
-function validateDocumentStrict(document, schema) {
-  const extras = [];
-  collectExtraFields(document, schema, "", extras);
-  if (extras.length > 0) {
+function registerStopWords(name, stopWords) {
+  requireName(name, "stop word set");
+  if (!(stopWords instanceof Set) && typeof stopWords !== "function") {
     throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Document contains fields not defined in schema: ${extras.join(", ")}`,
-      { extraFields: extras }
+      ErrorCodes.CONFIG_INVALID,
+      `Stop word set "${name}" needs a Set of words or a function returning one`,
+      { stopWords: name }
     );
   }
+  stopWordSets.set(name, stopWords);
 }
-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 hasTokenizer(name) {
+  return tokenizers.has(name);
 }
-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
-      });
-    }
-  }
+function hasStopWords(name) {
+  return stopWordSets.has(name);
 }
-
-// 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 getTokenizer(name) {
+  const tokenizer = tokenizers.get(name);
+  if (!tokenizer) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Tokenizer "${name}" is not registered on this engine`, {
+      tokenizer: name,
+      available: [...tokenizers.keys()]
     });
   }
+  return tokenizer;
 }
-function validateSchema(schema) {
-  if (!isPlainObject(schema)) {
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must be a plain object", {
-      received: typeof schema
+function getStopWords(name) {
+  const stopWords = stopWordSets.get(name);
+  if (!stopWords) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Stop word set "${name}" is not registered on this engine`, {
+      stopWords: name,
+      available: [...stopWordSets.keys()]
     });
   }
-  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;
+  return stopWords;
 }
-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;
+function resolveIndexAnalysis(config) {
+  return {
+    stopWords: typeof config.stopWords === "string" ? getStopWords(config.stopWords) : config.stopWords,
+    customTokenizer: typeof config.tokenizer === "string" ? getTokenizer(config.tokenizer) : config.tokenizer
+  };
 }
 
-// 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/serialization/constants.ts
+var CHECKSUM_TIMEOUT_MS = 12e4;
+var CHECKSUM_YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
+var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function metadataToWire(meta) {
   const wire = {
     index_name: meta.indexName,
@@ -596,8 +210,8 @@ function wireToMetadata(raw) {
   }
   if (raw.partition_limits && typeof raw.partition_limits === "object") {
     const limits = {
-      ...isPositiveInteger2(raw.partition_limits.max_docs_per_partition) ? { maxDocsPerPartition: raw.partition_limits.max_docs_per_partition } : {},
-      ...isPositiveInteger2(raw.partition_limits.max_partitions) ? { maxPartitions: raw.partition_limits.max_partitions } : {},
+      ...isPositiveInteger(raw.partition_limits.max_docs_per_partition) ? { maxDocsPerPartition: raw.partition_limits.max_docs_per_partition } : {},
+      ...isPositiveInteger(raw.partition_limits.max_partitions) ? { maxPartitions: raw.partition_limits.max_partitions } : {},
       ...isWatermarkFraction(raw.partition_limits.watermark) ? { watermark: raw.partition_limits.watermark } : {}
     };
     if (Object.keys(limits).length > 0) {
@@ -622,16 +236,16 @@ function wireToMetadata(raw) {
     const metric = hnsw?.metric;
     const restored = {};
     const hnswConfig = {};
-    if (isPositiveInteger2(hnsw?.m)) {
+    if (isPositiveInteger(hnsw?.m)) {
       hnswConfig.m = hnsw?.m;
     }
-    if (isPositiveInteger2(hnsw?.ef_construction)) {
+    if (isPositiveInteger(hnsw?.ef_construction)) {
       hnswConfig.efConstruction = hnsw?.ef_construction;
     }
     if (metric === "cosine" || metric === "dotProduct" || metric === "euclidean") {
       hnswConfig.metric = metric;
     }
-    if (isPositiveInteger2(promotion.threshold)) {
+    if (isPositiveInteger(promotion.threshold)) {
       restored.threshold = promotion.threshold;
     }
     if (isSelectivityRatio(promotion.filter_threshold)) {
@@ -658,7 +272,7 @@ function wireToMetadata(raw) {
 function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
-function isPositiveInteger2(value) {
+function isPositiveInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 1;
 }
 function isSelectivityRatio(value) {
@@ -678,17 +292,17 @@ function deserializeMetadata(data) {
 
 // src/serialization/stored-vector-values.ts
 function dropStoredVectorValues(documents, schema) {
-  const vectorFieldPaths2 = [];
+  const vectorFieldPaths = [];
   for (const [fieldPath, fieldType] of Object.entries(schema)) {
     if (typeof fieldType === "string" && VECTOR_PATTERN.test(fieldType)) {
-      vectorFieldPaths2.push(fieldPath);
+      vectorFieldPaths.push(fieldPath);
     }
   }
-  if (vectorFieldPaths2.length === 0) {
+  if (vectorFieldPaths.length === 0) {
     return;
   }
   for (const document of Object.values(documents)) {
-    for (const fieldPath of vectorFieldPaths2) {
+    for (const fieldPath of vectorFieldPaths) {
       removeFieldAtPath(document.fields, fieldPath);
     }
   }
@@ -726,7 +340,6 @@ function sanitizeSurfaceForms(raw) {
   }
   return count > 0 ? result : void 0;
 }
-var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function validateHnswMetric(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
@@ -824,10 +437,9 @@ function deserializePayloadV1(data) {
 function encodeRawPayloadV2(wire) {
   return encode(wire);
 }
-var VALID_HNSW_METRICS2 = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function validateHnswMetric2(value) {
   if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS2.has(value)) {
+  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
     return value;
   }
   return void 0;
@@ -1168,65 +780,18 @@ function createDocumentStore() {
   };
 }
 
-// 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/core/constants.ts
+var POSTING_LIST_INITIAL_CAPACITY = 8;
+var POSTING_LIST_COMPACTION_THRESHOLD = 0.3;
+var MAX_TERM_FREQUENCY = 65535;
 
 // src/core/posting-list.ts
-var INITIAL_CAPACITY = 8;
-var MAX_TERM_FREQUENCY = 65535;
-var COMPACTION_THRESHOLD = 0.3;
 function createPostingList() {
   return {
     length: 0,
     docIds: [],
-    termFrequencies: new Uint16Array(INITIAL_CAPACITY),
-    fieldNameIndices: new Uint8Array(INITIAL_CAPACITY),
+    termFrequencies: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
+    fieldNameIndices: new Uint8Array(POSTING_LIST_INITIAL_CAPACITY),
     positions: null,
     docIdSet: /* @__PURE__ */ new Set(),
     deletedDocs: /* @__PURE__ */ new Set(),
@@ -1394,7 +959,7 @@ function createInvertedIndex(fieldNameTable) {
         batchDirtyTokens.add(token);
         return;
       }
-      if (list.deletedDocs.size / list.length > COMPACTION_THRESHOLD) {
+      if (list.deletedDocs.size / list.length > POSTING_LIST_COMPACTION_THRESHOLD) {
         compactList(list);
       }
     },
@@ -1407,7 +972,7 @@ function createInvertedIndex(fieldNameTable) {
       for (const token of batchDirtyTokens) {
         const list = index.get(token);
         if (!list) continue;
-        if (list.deletedDocs.size / list.length > COMPACTION_THRESHOLD) {
+        if (list.deletedDocs.size / list.length > POSTING_LIST_COMPACTION_THRESHOLD) {
           compactList(list);
         }
       }
@@ -1551,137 +1116,6 @@ function createInvertedIndex(fieldNameTable) {
   };
 }
 
-// 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/statistics.ts
 function applyUniqueTokens(tokens, docFrequencies, increment) {
   const fields = Object.keys(tokens);
@@ -1925,84 +1359,23 @@ function createSurfaceRegistry() {
   };
 }
 
-// src/core/bitset.ts
-function createBitSet(capacity) {
-  return new Uint32Array(capacity + 31 >>> 5 || 1);
+// src/core/partition/utils.ts
+function getOrCreateFieldNameIndex(table, fieldName) {
+  const existing = table.indexMap.get(fieldName);
+  if (existing !== void 0) return existing;
+  const idx = table.names.length;
+  table.names.push(fieldName);
+  table.indexMap.set(fieldName, idx);
+  return idx;
 }
-function bitsetSet(bs, index) {
-  const word = index >>> 5;
-  if (word < bs.length) {
-    bs[word] |= 1 << (index & 31);
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length; i++) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[parts[i]];
   }
-}
-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/partition/utils.ts
-function getOrCreateFieldNameIndex(table, fieldName) {
-  const existing = table.indexMap.get(fieldName);
-  if (existing !== void 0) return existing;
-  const idx = table.names.length;
-  table.names.push(fieldName);
-  table.indexMap.set(fieldName, idx);
-  return idx;
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length; i++) {
-    if (current === null || current === void 0 || typeof current !== "object") return void 0;
-    current = current[parts[i]];
-  }
-  return current;
+  return current;
 }
 function stringArraysEqual(a, b) {
   if (a === b) return true;
@@ -2190,9 +1563,13 @@ function computeFacets(state, matched, config, schema) {
   return result;
 }
 
+// src/geo/constants.ts
+var DEG_TO_RAD = Math.PI / 180;
+var VINCENTY_MAX_ITERATIONS = 200;
+var VINCENTY_CONVERGENCE_THRESHOLD = 1e-12;
+
 // src/geo/haversine.ts
 var EARTH_RADIUS_METERS = 63710088e-1;
-var DEG_TO_RAD = Math.PI / 180;
 function haversineDistance(lat1, lon1, lat2, lon2) {
   const phi1 = lat1 * DEG_TO_RAD;
   const phi2 = lat2 * DEG_TO_RAD;
@@ -2230,13 +1607,10 @@ function isPointInPolygon(lat, lon, polygon) {
 var WGS84_A = 6378137;
 var WGS84_F = 1 / 298.257223563;
 var WGS84_B = WGS84_A * (1 - WGS84_F);
-var DEG_TO_RAD2 = Math.PI / 180;
-var MAX_ITERATIONS = 200;
-var CONVERGENCE_THRESHOLD = 1e-12;
 function vincentyDistance(lat1, lon1, lat2, lon2) {
-  const phi1 = lat1 * DEG_TO_RAD2;
-  const phi2 = lat2 * DEG_TO_RAD2;
-  const L = (lon2 - lon1) * DEG_TO_RAD2;
+  const phi1 = lat1 * DEG_TO_RAD;
+  const phi2 = lat2 * DEG_TO_RAD;
+  const L = (lon2 - lon1) * DEG_TO_RAD;
   const U1 = Math.atan((1 - WGS84_F) * Math.tan(phi1));
   const U2 = Math.atan((1 - WGS84_F) * Math.tan(phi2));
   const sinU1 = Math.sin(U1);
@@ -2251,7 +1625,7 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
   let sinAlpha = 0;
   let cos2Alpha = 0;
   let cos2SigmaM = 0;
-  let iterations = MAX_ITERATIONS;
+  let iterations = VINCENTY_MAX_ITERATIONS;
   do {
     const sinLambda = Math.sin(lambda);
     const cosLambda = Math.cos(lambda);
@@ -2267,7 +1641,7 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
     const C = WGS84_F / 16 * cos2Alpha * (4 + WGS84_F * (4 - 3 * cos2Alpha));
     prevLambda = lambda;
     lambda = L + (1 - C) * WGS84_F * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
-  } while (Math.abs(lambda - prevLambda) > CONVERGENCE_THRESHOLD && --iterations > 0);
+  } while (Math.abs(lambda - prevLambda) > VINCENTY_CONVERGENCE_THRESHOLD && --iterations > 0);
   if (iterations === 0) {
     return haversineDistance(lat1, lon1, lat2, lon2);
   }
@@ -2696,452 +2070,6 @@ function createNumericIndex() {
   };
 }
 
-// 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
-var CACHE_SIZE_FLOOR = 5e4;
-var CACHE_SIZE_CEILING = 2e6;
-var BYTES_PER_ENTRY = 200;
-var NODE_CACHE_ENTRIES = 1e6;
-var UNKNOWN_MEMORY_CACHE_ENTRIES = 2e5;
-function clampCacheSize(entries) {
-  return Math.max(CACHE_SIZE_FLOOR, Math.min(entries, 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) {
-        return clampCacheSize(Math.floor(constrainedMemory * 0.05 / BYTES_PER_ENTRY));
-      }
-      return clampCacheSize(NODE_CACHE_ENTRIES);
-    }
-    if (typeof navigator !== "undefined") {
-      const mem = navigator.deviceMemory;
-      if (typeof mem === "number" && mem > 0) {
-        let entries;
-        if (mem <= 1) entries = 1e5;
-        else if (mem <= 4) entries = 25e4;
-        else entries = 5e5;
-        return clampCacheSize(entries);
-      }
-    }
-  } catch {
-    return clampCacheSize(UNKNOWN_MEMORY_CACHE_ENTRIES);
-  }
-  return clampCacheSize(UNKNOWN_MEMORY_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(CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), 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;
-var DEFAULT_MIN_TOKEN_LENGTH = 1;
-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/core/partition/indexing.ts
 function ensureFieldIndex(state, fieldPath, fieldType) {
   if ((fieldType === "number" || fieldType === "number[]") && !state.numericIndexes.has(fieldPath)) {
@@ -3998,14 +2926,27 @@ function partitionFilterMatches(state, filters, schema) {
   };
 }
 
+// src/core/partition/posting-columns.ts
+function postingColumns(list) {
+  const deletedDocs = list.deletedDocs;
+  return {
+    docIds: list.docIds,
+    termFrequencies: list.termFrequencies,
+    fieldNameIndices: list.fieldNameIndices,
+    deletedDocs,
+    hasDeleted: deletedDocs.size > 0,
+    count: list.length
+  };
+}
+
 // src/core/partition/matches.ts
 function markPostingList(matched, list, fieldNames, fields, filterBitset) {
-  const hasDeleted = list.deletedDocs.size > 0;
-  for (let pi = 0; pi < list.length; pi++) {
-    const internalId = list.docIds[pi];
-    if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
+  for (let pi = 0; pi < count; pi++) {
+    const internalId = docIds[pi];
+    if (hasDeleted && deletedDocs.has(internalId)) continue;
     if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-    if (fields && !fields.includes(fieldNames[list.fieldNameIndices[pi]])) continue;
+    if (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) continue;
     bitsetSet(matched, internalId);
   }
 }
@@ -4076,6 +3017,12 @@ function searchFulltextMatches(state, params) {
   };
 }
 
+// src/core/partition/constants.ts
+var TARGET_BLOCK_ENTRIES = 128;
+var SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY = 1024;
+var SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD = 1024;
+var SORT_COLUMN_REBUILD_FRACTION_SHIFT = 2;
+
 // src/core/partition/sort-columns/order.ts
 var MISSING_RANK = -1;
 var BYTES_PER_RANK = 4;
@@ -4301,8 +3248,6 @@ function createValueStore(initialKind) {
 }
 
 // src/core/partition/sort-columns/index.ts
-var MINIMUM_REBUILD_THRESHOLD = 1024;
-var REBUILD_FRACTION_SHIFT = 2;
 function liveInternalIds(docStore) {
   const ids = [];
   for (const internalId of docStore.allInternalIds()) ids.push(internalId);
@@ -4312,8 +3257,8 @@ function createSortColumnSet(docStore) {
   const columns = /* @__PURE__ */ new Map();
   function rebuildThreshold() {
     const count = docStore.count();
-    const fraction = count >> REBUILD_FRACTION_SHIFT;
-    return fraction > MINIMUM_REBUILD_THRESHOLD ? fraction : MINIMUM_REBUILD_THRESHOLD;
+    const fraction = count >> SORT_COLUMN_REBUILD_FRACTION_SHIFT;
+    return fraction > SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD ? fraction : SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD;
   }
   function rebuild(entry) {
     entry.order = buildOrder(entry.store, docStore.allInternalIds(), docStore.internalIdCapacity());
@@ -4942,13 +3887,12 @@ function sortSelection(heap) {
 }
 
 // src/core/partition/score-buffer.ts
-var INITIAL_TOUCHED_CAPACITY = 1024;
 var MAX_GENERATION = 2147483647;
 function createScoreBuffer(capacity) {
   return {
     scores: new Float64Array(capacity),
     stamps: new Int32Array(capacity),
-    touched: new Int32Array(Math.max(1, Math.min(capacity, INITIAL_TOUCHED_CAPACITY))),
+    touched: new Int32Array(Math.max(1, Math.min(capacity, SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY))),
     touchedCount: 0,
     generation: 0
   };
@@ -5033,7 +3977,6 @@ function topKFromBuffer(buffer, k, resolver, components) {
 }
 
 // src/core/partition/block-bounds.ts
-var TARGET_BLOCK_ENTRIES = 128;
 var ABSENT_FIELD_LENGTH_BOUND = 0;
 var boundsByList = /* @__PURE__ */ new WeakMap();
 function fieldLengthBound(columns, fieldIndex, internalId) {
@@ -5142,12 +4085,27 @@ function bestSearchable(searchable, values) {
   }
   return best;
 }
+function prunableSingleTermList(params, index) {
+  if (params.queryTokens.length !== 1) return null;
+  if (params.prefixExpansion !== void 0) return null;
+  if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
+  if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
+  if (params.collectComponents !== false) return null;
+  if (params.collectMatchedSet !== void 0) return null;
+  if (params.maxResults === void 0) return null;
+  if (params.fields !== void 0) return null;
+  if (params.filterBitset !== void 0) return null;
+  if (!bm25PruningSound(params.bm25Params)) return null;
+  const list = index.lookup(params.queryTokens[0].token);
+  if (list === void 0) return null;
+  if (!list.ordered) return null;
+  return list;
+}
 function singleTermTopK(request) {
   const { list, docFrequency, totalDocs, bm25Params, limit, resolver } = request;
   const { fieldSearchable, fieldBoosts, fieldAvgLengths, fieldLengthColumns } = request;
   const wanted = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
-  const deleted = list.deletedDocs;
-  const hasDeleted = deleted.size > 0;
+  const { docIds, termFrequencies, fieldNameIndices, deletedDocs: deleted, hasDeleted } = postingColumns(list);
   const bounds = blockBoundsFor(list, fieldLengthColumns);
   const maxBoost = bestSearchable(fieldSearchable, fieldBoosts);
   const maxAverageLength = bestSearchable(fieldSearchable, fieldAvgLengths);
@@ -5174,19 +4132,19 @@ function singleTermTopK(request) {
     }
     let entry = start;
     while (entry < end) {
-      const internalId = list.docIds[entry];
+      const internalId = docIds[entry];
       if (hasDeleted && deleted.has(internalId)) {
-        while (entry < end && list.docIds[entry] === internalId) entry++;
+        while (entry < end && docIds[entry] === internalId) entry++;
         continue;
       }
       let score = 0;
       let scored2 = false;
-      while (entry < end && list.docIds[entry] === internalId) {
-        const fieldIndex = list.fieldNameIndices[entry];
+      while (entry < end && docIds[entry] === internalId) {
+        const fieldIndex = fieldNameIndices[entry];
         if (fieldSearchable[fieldIndex] === 1) {
           const fieldLength = fieldLengthOf(fieldLengthColumns, fieldIndex, internalId, fieldAvgLengths[fieldIndex]);
           score += computeBM25(
-            list.termFrequencies[entry],
+            termFrequencies[entry],
             docFrequency,
             totalDocs,
             fieldLength,
@@ -5238,21 +4196,10 @@ function singleTermTopK(request) {
 function globalDocFreqFor(docFreqs, term, fallback) {
   return Object.hasOwn(docFreqs, term) ? docFreqs[term] : fallback;
 }
-function prunableSingleTermList(params, index) {
-  if (params.queryTokens.length !== 1) return null;
-  if (params.prefixExpansion !== void 0) return null;
-  if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
-  if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
-  if (params.collectComponents !== false) return null;
-  if (params.collectMatchedSet !== void 0) return null;
-  if (params.maxResults === void 0) return null;
-  if (params.fields !== void 0) return null;
-  if (params.filterBitset !== void 0) return null;
-  if (!bm25PruningSound(params.bm25Params)) return null;
-  const list = index.lookup(params.queryTokens[0].token);
-  if (list === void 0) return null;
-  if (!list.ordered) return null;
-  return list;
+function matchesFor(index, token, exact, tolerance, prefixLength) {
+  if (!exact) return index.fuzzyLookup(token, tolerance, prefixLength);
+  const postingList = index.lookup(token);
+  return postingList ? [{ token, postingList }] : [];
 }
 function searchFulltext(state, params) {
   const {
@@ -5333,17 +4280,18 @@ function searchFulltext(state, params) {
     const best = /* @__PURE__ */ new Map();
     for (const match of matches) {
       const perTerm = /* @__PURE__ */ new Map();
-      const list = match.postingList;
-      const hasDeleted = list.deletedDocs.size > 0;
-      for (let pi = 0; pi < list.length; pi++) {
-        const internalId = list.docIds[pi];
-        if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+      const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+        match.postingList
+      );
+      for (let pi = 0; pi < count; pi++) {
+        const internalId = docIds[pi];
+        if (hasDeleted && deletedDocs.has(internalId)) continue;
         if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-        const fieldIndex = list.fieldNameIndices[pi];
+        const fieldIndex = fieldNameIndices[pi];
         loadFieldMeta(fieldIndex);
         if (fieldSearchable[fieldIndex] === 0) continue;
         const fieldName = fieldNames[fieldIndex];
-        const termFrequency = list.termFrequencies[pi];
+        const termFrequency = termFrequencies[pi];
         const fieldBoost = fieldBoosts[fieldIndex];
         const avgLen = fieldAvgLengths[fieldIndex];
         const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -5415,10 +4363,7 @@ function searchFulltext(state, params) {
         resolved.push({ token: qt.token, matches: [], totalPostings: totalPostings2, isPrefix: true });
         continue;
       }
-      const rawMatches = exact ? (() => {
-        const postingList = state.invertedIdx.lookup(qt.token);
-        return postingList ? [{ token: qt.token, postingList }] : [];
-      })() : state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength);
+      const rawMatches = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
       let totalPostings = 0;
       const matches = [];
       for (const m of rawMatches) {
@@ -5440,17 +4385,18 @@ function searchFulltext(state, params) {
         continue;
       }
       for (const match of resolved[tokenIndex].matches) {
-        const list = match.postingList;
-        const hasDeleted = list.deletedDocs.size > 0;
-        for (let pi = 0; pi < list.length; pi++) {
-          const internalId = list.docIds[pi];
-          if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+          match.postingList
+        );
+        for (let pi = 0; pi < count; pi++) {
+          const internalId = docIds[pi];
+          if (hasDeleted && deletedDocs.has(internalId)) continue;
           if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
           if (tokenIndex > 0 && !hasScore(scoreBuffer, internalId)) continue;
-          const fieldIndex = list.fieldNameIndices[pi];
+          const fieldIndex = fieldNameIndices[pi];
           loadFieldMeta(fieldIndex);
           if (fieldSearchable[fieldIndex] === 0) continue;
-          const termFrequency = list.termFrequencies[pi];
+          const termFrequency = termFrequencies[pi];
           const fieldBoost = fieldBoosts[fieldIndex];
           const avgLen = fieldAvgLengths[fieldIndex];
           const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -5483,23 +4429,21 @@ function searchFulltext(state, params) {
         }
         continue;
       }
-      const matchingPostings = exact ? (() => {
-        const postingList = state.invertedIdx.lookup(qt.token);
-        return postingList ? [{ token: qt.token, postingList }] : [];
-      })() : state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength);
+      const matchingPostings = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
       for (const match of matchingPostings) {
         const docFreq = globalStats ? globalDocFreqFor(globalDocFreqs, match.token, match.postingList.docIdSet.size) : match.postingList.docIdSet.size;
         const idf = computeIDF(docFreq, totalDocs);
-        const list = match.postingList;
-        const hasDeleted = list.deletedDocs.size > 0;
-        for (let pi = 0; pi < list.length; pi++) {
-          const internalId = list.docIds[pi];
-          if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+          match.postingList
+        );
+        for (let pi = 0; pi < count; pi++) {
+          const internalId = docIds[pi];
+          if (hasDeleted && deletedDocs.has(internalId)) continue;
           if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-          const fieldIndex = list.fieldNameIndices[pi];
+          const fieldIndex = fieldNameIndices[pi];
           loadFieldMeta(fieldIndex);
           if (fieldSearchable[fieldIndex] === 0) continue;
-          const termFrequency = list.termFrequencies[pi];
+          const termFrequency = termFrequencies[pi];
           const fieldBoost = fieldBoosts[fieldIndex];
           const avgLen = fieldAvgLengths[fieldIndex];
           const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -6412,32 +5356,21 @@ function createPartitionIndex(partitionId, trackPositions = true) {
   return partition;
 }
 
-// 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/id-generator.ts
+function generateId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const now = Date.now();
+  bytes[0] = Math.floor(now / 2 ** 40);
+  bytes[1] = Math.floor(now / 2 ** 32) % 256;
+  bytes[2] = Math.floor(now / 2 ** 24) % 256;
+  bytes[3] = Math.floor(now / 2 ** 16) % 256;
+  bytes[4] = Math.floor(now / 2 ** 8) % 256;
+  bytes[5] = now % 256;
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
 // src/core/partition/frozen/doc-table.ts
@@ -7147,6 +6080,9 @@ function createFrozenTombstones() {
       removed.add(internalId);
       revision++;
       return true;
+    },
+    values() {
+      return removed.values();
     }
   };
 }
@@ -7270,7 +6206,7 @@ function buildGeoReaders(entries) {
   }
   return readers;
 }
-function assembleFrozenSegment(segmentId, source, documentSource) {
+function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot) {
   const tombstones = createFrozenTombstones();
   const postingViews = createFrozenPostingViews(source, tombstones);
   const lengthColumns = /* @__PURE__ */ new Map();
@@ -7291,6 +6227,7 @@ function assembleFrozenSegment(segmentId, source, documentSource) {
   const segment = {
     segmentId,
     documentSource,
+    sharedSnapshot,
     invertedIdx: createFrozenInvertedReader(source.tokenTable, postingViews),
     docStore,
     stats: buildStatsView(source),
@@ -7321,6 +6258,11 @@ function assembleFrozenSegment(segmentId, source, documentSource) {
         segment.scoreBuffer = null;
       }
       return added;
+    },
+    tombstonedDocIds() {
+      const docIds = [];
+      for (const ordinal of tombstones.values()) docIds.push(source.idTable.idAt(ordinal));
+      return docIds;
     }
   };
   return segment;
@@ -7334,7 +6276,8 @@ function createFrozenSegment(payload, documents, segmentId) {
       idTable: buildExternalIdTable(payload.docIds),
       docFrequencies: () => payload.docFrequencies
     },
-    wrapDocumentArray(documents)
+    wrapDocumentArray(documents),
+    null
   );
 }
 function createSharedFrozenSegment(snapshot) {
@@ -7353,7 +6296,8 @@ function createSharedFrozenSegment(snapshot) {
         return frequencies;
       }
     },
-    wrapEncodedDocumentTable(snapshot.documentTable)
+    wrapEncodedDocumentTable(snapshot.documentTable),
+    snapshot
   );
 }
 
@@ -7395,6 +6339,15 @@ function buildCompactedSegmentPayload(segments) {
   }
   return { payload: scratch.encodeSegment(), documents };
 }
+function freezeLiveTailInto(live, liveState, frozen, freeze) {
+  if (live.count() === 0) return null;
+  const payload = live.encodeSegment();
+  const segment = freeze(payload, survivorDocumentsOf(liveState, payload));
+  if (segment === null) return null;
+  live.clear();
+  frozen.push(segment);
+  return segment;
+}
 function swapFrozenSegmentList(frozen, dropSegmentIds, replacement, partitionId) {
   const dropped = resolveFrozenSegments(frozen, dropSegmentIds, partitionId);
   const dropSet = new Set(dropSegmentIds);
@@ -7434,11 +6387,15 @@ function subBitsetView(composite, layout, subIndex) {
   const endWord = subIndex + 1 < layout.bases.length ? layout.bases[subIndex + 1] >> 5 : Math.ceil(layout.totalCapacity / WORD_BITS);
   return composite.subarray(startWord, endWord);
 }
+function placeSubBitset(composite, layout, subIndex, subBits) {
+  const words = subBitsetView(composite, layout, subIndex).length;
+  if (words === 0) return;
+  composite.set(subBits.length > words ? subBits.subarray(0, words) : subBits, layout.bases[subIndex] >> 5);
+}
 function compositeFiltersBitset(subs, layout, filters, schema) {
   const composite = new Uint32Array(Math.ceil(layout.totalCapacity / WORD_BITS));
   for (let i = 0; i < subs.length; i++) {
-    const subBits = applyPartitionFiltersBitset(subs[i], filters, schema);
-    composite.set(subBits, layout.bases[i] >> 5);
+    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema));
   }
   return composite;
 }
@@ -7491,123 +6448,6 @@ function subMatchesView(matches, layout, subIndex) {
   };
 }
 
-// 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/core/partition/composite/stats.ts
 function collectCandidateTerms(subs, params) {
   const { queryTokens, prefixExpansion, tolerance = 0, prefixLength = 2, exact = false } = params;
@@ -7700,10 +6540,30 @@ function subParams(params, layout, subIndex, globalStats) {
     filterBitset: params.filterBitset === void 0 ? void 0 : subBitsetView(params.filterBitset, layout, subIndex)
   };
 }
+function onlyPopulatedSub(subs) {
+  let found = -1;
+  for (let i = 0; i < subs.length; i++) {
+    if (subs[i].stats.totalDocuments === 0) continue;
+    if (found !== -1) return -1;
+    found = i;
+  }
+  return found;
+}
+function searchSingleSub(subs, layout, params, index) {
+  const result = searchFulltext(subs[index], subParams(params, layout, index, params.globalStats));
+  if (result.matchedOrdinalBitset === void 0) return result;
+  const matchedOrdinalBitset = createBitSet(layout.totalCapacity);
+  placeSubBitset(matchedOrdinalBitset, layout, index, result.matchedOrdinalBitset);
+  return { ...result, matchedOrdinalBitset };
+}
 function compositeSearchFulltext(subs, layout, params) {
   if (params.queryTokens.length === 0) {
     return { scored: [], totalMatched: 0 };
   }
+  const single = onlyPopulatedSub(subs);
+  if (single !== -1) {
+    return searchSingleSub(subs, layout, params, single);
+  }
   const globalStats = compositeQueryStats(subs, params);
   const results = subs.map((sub, index) => searchFulltext(sub, subParams(params, layout, index, globalStats)));
   const scored = kWayMerge(results.map((result) => result.scored));
@@ -7721,7 +6581,7 @@ function compositeSearchFulltext(subs, layout, params) {
     const matchedOrdinalBitset = createBitSet(layout.totalCapacity);
     for (let i = 0; i < results.length; i++) {
       const subBitset = results[i].matchedOrdinalBitset;
-      if (subBitset !== void 0) matchedOrdinalBitset.set(subBitset, layout.bases[i] >> 5);
+      if (subBitset !== void 0) placeSubBitset(matchedOrdinalBitset, layout, i, subBitset);
     }
     return { scored, totalMatched, matchedOrdinalBitset };
   }
@@ -7765,7 +6625,7 @@ function compositeSearchMatches(subs, layout, params) {
     ordinalBitset() {
       const combined = createBitSet(layout.totalCapacity);
       for (let i = 0; i < subMatches.length; i++) {
-        combined.set(subMatches[i].ordinalBitset(), layout.bases[i] >> 5);
+        placeSubBitset(combined, layout, i, subMatches[i].ordinalBitset());
       }
       return combined;
     }
@@ -7848,17 +6708,6 @@ function compositeExpandTermPrefix(subs, surfacePrefix, stemmedToken, maxExpansi
 function isCompositePartition(partition) {
   return "attachFrozenSegment" in partition;
 }
-function survivorDocuments(sub, payload) {
-  return payload.docIds.map((docId) => {
-    const stored = sub.docStore.get(docId);
-    if (stored === void 0) {
-      throw new NarsilError(ErrorCodes.PARTITION_CORRUPTED, `Document "${docId}" vanished while composing a segment`, {
-        docId
-      });
-    }
-    return stored.fields;
-  });
-}
 function createCompositePartition(partitionId, trackPositions = true, existingLive) {
   const live = existingLive ?? createPartitionIndex(partitionId, trackPositions);
   const liveState = partitionStateOf(live);
@@ -7881,7 +6730,7 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
     for (const sub of subs()) {
       const payload = encodeSegmentState(sub);
       if (payload.documentCount === 0) continue;
-      scratch.mergeSegmentPayload(payload, survivorDocuments(sub, payload));
+      scratch.mergeSegmentPayload(payload, survivorDocumentsOf(sub, payload));
     }
     return scratch;
   }
@@ -7917,6 +6766,16 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       swapFrozenSegmentList(frozen, dropSegmentIds, replacement, partitionId);
       invalidateDocFrequencies();
     },
+    freezeLiveTail(freeze) {
+      const segment = freezeLiveTailInto(live, liveState, frozen, freeze);
+      if (segment !== null) invalidateDocFrequencies();
+      return segment;
+    },
+    replaceLiveTail(segment) {
+      live.clear();
+      frozen.push(segment);
+      invalidateDocFrequencies();
+    },
     appendFrozenSegment(payload, documents) {
       for (const docId of payload.docIds) {
         if (live.has(docId) || frozenOwner(docId) !== void 0) {
@@ -7961,7 +6820,7 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
         for (const segment of frozen) {
           const payload = encodeSegmentState(segment);
           if (payload.documentCount === 0) continue;
-          live.mergeSegmentPayload(payload, survivorDocuments(segment, payload));
+          live.mergeSegmentPayload(payload, survivorDocumentsOf(segment, payload));
         }
         frozen.length = 0;
       }
@@ -8120,792 +6979,30 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
     },
     estimateMemoryBytes() {
       let total = live.estimateMemoryBytes();
-      for (const segment of frozen) {
-        total += estimatePartitionBytes(segment);
-      }
-      return total;
-    }
-  };
-}
-
-// src/languages/registry.ts
-var languages = /* @__PURE__ */ new Map();
-languages.set("english", english);
-function registerLanguage(module) {
-  languages.set(module.name, module);
-}
-function getLanguage(name) {
-  const lang = languages.get(name);
-  if (!lang) {
-    throw new NarsilError(ErrorCodes.LANGUAGE_NOT_SUPPORTED, `Language "${name}" is not registered`, { language: name });
-  }
-  return lang;
-}
-
-// 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/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;
-var MAX_CURSOR_LENGTH = 40960;
-var MAX_SORT_FIELDS = 8;
-var MAX_SORT_FIELD_NAME_LENGTH = 255;
-var MAX_ANCHOR_CODE_POINTS = 512;
-var MAX_SORT_VALUE_CODE_POINTS = 512;
-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, MAX_SORT_VALUE_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_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
-var RESULT_WINDOW = 1e4;
-var DEFAULT_PAGE_SIZE = 10;
-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
-var PREFIX_MAX_EXPANSIONS = 50;
-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/insert-options.ts
-function resolvePartitionInsertOptions(config, analysis, options) {
-  const applyStrict = config.strict === true;
-  const applyAnalyzer = analysis.stopWords !== void 0 || analysis.customTokenizer !== void 0;
-  const applySurfaces = config.surfaceForms !== false;
-  if (!applyStrict && !applyAnalyzer && !applySurfaces) return options;
-  const resolved = { ...options };
-  if (applyStrict) resolved.strict = true;
-  if (applyAnalyzer) {
-    resolved.stopWordOverride = options?.stopWordOverride ?? analysis.stopWords;
-    resolved.customTokenizer = options?.customTokenizer ?? analysis.customTokenizer;
-  }
-  if (applySurfaces) resolved.collectSurfaces = true;
-  return resolved;
-}
-
-// src/analysis/registry.ts
-var tokenizers = /* @__PURE__ */ new Map();
-var stopWordSets = /* @__PURE__ */ new Map();
-function requireName(name, kind) {
-  if (typeof name !== "string" || name.trim().length === 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `A registered ${kind} needs a non-empty name`, { name });
-  }
-}
-function registerTokenizer(name, tokenizer) {
-  requireName(name, "tokenizer");
-  if (typeof tokenizer?.tokenize !== "function") {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Tokenizer "${name}" needs a tokenize method`, { tokenizer: name });
-  }
-  tokenizers.set(name, tokenizer);
-}
-function registerStopWords(name, stopWords) {
-  requireName(name, "stop word set");
-  if (!(stopWords instanceof Set) && typeof stopWords !== "function") {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      `Stop word set "${name}" needs a Set of words or a function returning one`,
-      { stopWords: name }
-    );
-  }
-  stopWordSets.set(name, stopWords);
-}
-function hasTokenizer(name) {
-  return tokenizers.has(name);
-}
-function hasStopWords(name) {
-  return stopWordSets.has(name);
-}
-function getTokenizer(name) {
-  const tokenizer = tokenizers.get(name);
-  if (!tokenizer) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Tokenizer "${name}" is not registered on this engine`, {
-      tokenizer: name,
-      available: [...tokenizers.keys()]
-    });
-  }
-  return tokenizer;
-}
-function getStopWords(name) {
-  const stopWords = stopWordSets.get(name);
-  if (!stopWords) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Stop word set "${name}" is not registered on this engine`, {
-      stopWords: name,
-      available: [...stopWordSets.keys()]
-    });
-  }
-  return stopWords;
-}
-function resolveIndexAnalysis(config) {
-  return {
-    stopWords: typeof config.stopWords === "string" ? getStopWords(config.stopWords) : config.stopWords,
-    customTokenizer: typeof config.tokenizer === "string" ? getTokenizer(config.tokenizer) : config.tokenizer
+      for (const segment of frozen) {
+        total += estimatePartitionBytes(segment);
+      }
+      return total;
+    }
   };
 }
 
+// src/partitioning/insert-options.ts
+function resolvePartitionInsertOptions(config, analysis, options) {
+  const applyStrict = config.strict === true;
+  const applyAnalyzer = analysis.stopWords !== void 0 || analysis.customTokenizer !== void 0;
+  const applySurfaces = config.surfaceForms !== false;
+  if (!applyStrict && !applyAnalyzer && !applySurfaces) return options;
+  const resolved = { ...options };
+  if (applyStrict) resolved.strict = true;
+  if (applyAnalyzer) {
+    resolved.stopWordOverride = options?.stopWordOverride ?? analysis.stopWords;
+    resolved.customTokenizer = options?.customTokenizer ?? analysis.customTokenizer;
+  }
+  if (applySurfaces) resolved.collectSurfaces = true;
+  return resolved;
+}
+
 // src/partitioning/manager/nested-values.ts
 function setNestedValue(obj, path, value) {
   if (!path.includes(".")) {
@@ -9171,6 +7268,14 @@ function createPartitionManager(indexName, config, language, router, initialPart
         if (docId !== void 0) docPartitionMap.set(docId, partitionId);
       }
     },
+    freezeLiveTail(partitionId, freeze) {
+      validatePartitionId(partitionId);
+      return asCompositePartition(partitionId).freezeLiveTail(freeze);
+    },
+    replaceLiveTail(partitionId, segment) {
+      validatePartitionId(partitionId);
+      asCompositePartition(partitionId).replaceLiveTail(segment);
+    },
     deserializePartition(partitionId, data) {
       validatePartitionId(partitionId);
       partitions[partitionId].deserialize(data, config.schema);
@@ -9222,35 +7327,6 @@ function createPartitionManager(indexName, config, language, router, initialPart
   return manager;
 }
 
-// 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/hash.ts
-var FNV_OFFSET_BASIS = 2166136261;
-var FNV_PRIME = 16777619;
-var encoder3 = 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(encoder3.encode(input));
-}
-
 // src/partitioning/router.ts
 function createPartitionRouter() {
   function route(docId, partitionCount) {
@@ -9280,10 +7356,10 @@ function createPartitionRouter() {
 }
 
 // src/workers/node-worker.ts
-async function spawnNodeWorker(entryPoint) {
+async function spawnNodeWorker(entryPoint, resourceLimits) {
   try {
     const workerThreads = await import('worker_threads');
-    return new workerThreads.Worker(entryPoint);
+    return new workerThreads.Worker(entryPoint, { resourceLimits });
   } catch {
     return null;
   }
@@ -9297,42 +7373,7 @@ async function isNodeMainThread() {
   }
 }
 
-// src/runtime/detect.ts
-function detectRuntimeName() {
-  if ("Bun" in globalThis) {
-    return "bun";
-  }
-  if ("Deno" in globalThis) {
-    return "deno";
-  }
-  const proc = globalThis.process;
-  if (typeof proc === "object" && proc !== null && typeof proc.versions === "object" && typeof proc.versions?.node === "string") {
-    return "node";
-  }
-  return "browser";
-}
-function getCpuCount() {
-  const nav = globalThis.navigator;
-  if (nav && typeof nav.hardwareConcurrency === "number" && nav.hardwareConcurrency >= 1) {
-    return nav.hardwareConcurrency;
-  }
-  return 1;
-}
-function detectRuntime() {
-  const runtime = detectRuntimeName();
-  return {
-    runtime,
-    cpuCount: getCpuCount(),
-    supportsWorkerThreads: runtime === "node" || runtime === "bun",
-    supportsWebWorkers: runtime === "browser" || runtime === "deno" || runtime === "bun",
-    supportsFileSystem: runtime === "node" || runtime === "bun" || runtime === "deno",
-    supportsIndexedDB: runtime === "browser" || "indexedDB" in globalThis,
-    supportsBroadcastChannel: "BroadcastChannel" in globalThis
-  };
-}
-
 // src/vector/hnsw-worker-dispatch.ts
-var BUILD_TIMEOUT_MS = 12e4;
 function resolveWorkerEntryPoint() {
   const base = import.meta.url;
   const distIndex = base.lastIndexOf("/dist/");
@@ -9398,7 +7439,7 @@ async function dispatchWorkerBuild(docIds, vectorData, dimension, config, timeou
       message: "No worker thread support available in the current runtime"
     };
   }
-  const effectiveTimeout = timeoutMs ?? BUILD_TIMEOUT_MS;
+  const effectiveTimeout = timeoutMs ?? HNSW_BUILD_TIMEOUT_MS;
   let transferBuffer;
   if (skipCopy) {
     transferBuffer = vectorData;
@@ -9468,7 +7509,7 @@ async function dispatchWorkerBuild(docIds, vectorData, dimension, config, timeou
   });
 }
 
-// src/vector/vector-index/shared.ts
+// src/vector/vector-index/constants.ts
 var DEFAULT_PROMOTION_THRESHOLD = 1024;
 var DEFAULT_FILTER_THRESHOLD = 0.03;
 var ESTIMATED_MS_PER_TOMBSTONE = 0.05;
@@ -9477,9 +7518,25 @@ var WORKER_BUILD_SIZE_THRESHOLD = 5e3;
 var WORKER_COPY_MIN_VECTORS = 1024;
 var BUILD_CHUNK_SIZE = 100;
 var REBUILD_REMOVED_RATIO = 0.2;
+
+// src/vector/vector-index/shared.ts
+var VECTOR_WORKER_COPIES_ALLOWED = { enabled: true };
 function liveSize(state) {
   return state.store.size - state.tombstones.size;
 }
+function assignStorePartitions(state, resolve) {
+  for (let ordinal = 0; ordinal < state.store.slots; ordinal += 1) {
+    if (state.store.partitionOfOrdinal(ordinal) !== void 0) continue;
+    const docId = state.store.docIdForOrdinal(ordinal);
+    if (docId === void 0) continue;
+    const partitionId = resolve(docId);
+    if (partitionId === void 0) {
+      state.store.forgetPartition(docId);
+      continue;
+    }
+    state.store.setPartition(docId, partitionId);
+  }
+}
 function adoptGraph(state, graph) {
   if (graph === null && state.hnsw !== null) {
     state.hnsw.clear();
@@ -9588,28 +7645,53 @@ function recalibrateFromStore(state) {
   sq8.recalibrateAll(storeVectors());
 }
 
+// src/workers/constants.ts
+var WORKER_YOUNG_GENERATION_MB = 24;
+var MIN_WORKER_COUNT = 2;
+var MAX_WORKER_COUNT = 8;
+var FALLBACK_CPU_COUNT = 4;
+var MIN_CORES_FOR_SEVERAL_REQUEST_THREADS = 3;
+var DEFAULT_BACKPRESSURE_LIMIT = 100;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SHUTDOWN_TIMEOUT_MS = 5e3;
+var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
+
 // src/workers/pool.ts
 function toFinite(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function resolveWorkerCount(requested) {
-  if (requested !== void 0 && requested > 0) {
-    return requested;
-  }
-  let cpuCount = 4;
+function toHeapLimit(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function detectCpuCount() {
   try {
     if (navigator?.hardwareConcurrency) {
-      cpuCount = navigator.hardwareConcurrency;
-    } else if (typeof process !== "undefined") {
+      return navigator.hardwareConcurrency;
+    }
+    if (typeof process !== "undefined") {
       const ap = process.availableParallelism;
       if (typeof ap === "function") {
-        cpuCount = ap();
+        return ap();
       }
     }
   } catch {
-    cpuCount = 4;
+    return FALLBACK_CPU_COUNT;
+  }
+  return FALLBACK_CPU_COUNT;
+}
+function resolveWorkerCount(requested) {
+  if (requested !== void 0 && requested > 0) {
+    return requested;
   }
-  return Math.max(2, Math.min(8, cpuCount - 1));
+  return Math.max(MIN_WORKER_COUNT, Math.min(MAX_WORKER_COUNT, detectCpuCount() - 1));
+}
+function resolveRequestThreadCount(requested) {
+  if (detectCpuCount() < MIN_CORES_FOR_SEVERAL_REQUEST_THREADS) return 1;
+  return resolveWorkerCount(requested);
+}
+function splitWorkerBudget(total) {
+  const keyword = Math.ceil(total / 2);
+  return { keyword, vector: total - keyword };
 }
 function createWorkerPool(config) {
   const workerCount = resolveWorkerCount(config.count);
@@ -9618,29 +7700,61 @@ function createWorkerPool(config) {
   const indexAssignment = /* @__PURE__ */ new Map();
   let isShutdown = false;
   function handleWorkerDeath(slotIndex, error) {
-    if (isShutdown || deadSlots.has(slotIndex)) {
+    if (isShutdown) {
       return;
     }
-    deadSlots.add(slotIndex);
     const slot = workers.get(slotIndex);
+    if (slot !== void 0 && !slot.serving) {
+      workers.delete(slotIndex);
+      return;
+    }
+    if (deadSlots.has(slotIndex)) {
+      return;
+    }
+    deadSlots.add(slotIndex);
     const indexNames = slot ? [...slot.indexes].sort() : [];
     workers.delete(slotIndex);
     config.onWorkerCrash?.(slotIndex, indexNames, error);
   }
-  function ensureWorker(slotIndex) {
-    if (deadSlots.has(slotIndex)) {
-      return void 0;
-    }
-    let slot = workers.get(slotIndex);
-    if (!slot) {
-      slot = {
-        executor: config.workerFactory(slotIndex, (error) => handleWorkerDeath(slotIndex, error)),
-        indexes: /* @__PURE__ */ new Set()
-      };
-      workers.set(slotIndex, slot);
-    }
+  function spawnSlot(slotIndex, serving) {
+    const slot = {
+      executor: config.workerFactory(slotIndex, (error) => handleWorkerDeath(slotIndex, error)),
+      indexes: /* @__PURE__ */ new Set(),
+      inFlight: 0,
+      serving
+    };
+    workers.set(slotIndex, slot);
     return slot;
   }
+  function ensureWorker(slotIndex) {
+    const slot = workers.get(slotIndex);
+    if (slot !== void 0) return slot;
+    if (deadSlots.has(slotIndex)) return void 0;
+    return spawnSlot(slotIndex, true);
+  }
+  function deadWorkerIds() {
+    return [...deadSlots].filter((slotIndex) => !workers.has(slotIndex)).sort((a, b) => a - b);
+  }
+  function spawnReplacement(slotIndex) {
+    if (isShutdown || !deadSlots.has(slotIndex) || workers.has(slotIndex)) return null;
+    const slot = spawnSlot(slotIndex, false);
+    return {
+      workerId: slotIndex,
+      executor: slot.executor,
+      hold(indexName) {
+        slot.indexes.add(indexName);
+      },
+      admit() {
+        if (workers.get(slotIndex) !== slot) return;
+        deadSlots.delete(slotIndex);
+        slot.serving = true;
+      },
+      abandon() {
+        if (workers.get(slotIndex) === slot) workers.delete(slotIndex);
+        void slot.executor.shutdown().catch(() => void 0);
+      }
+    };
+  }
   function assignSlot(indexName) {
     const preferred = fnv1a(indexName) % workerCount;
     for (let probe = 0; probe < workerCount; probe++) {
@@ -9679,11 +7793,11 @@ function createWorkerPool(config) {
       throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" is not registered in the worker pool`);
     }
     const slot = workers.get(slotIndex);
-    if (slot) {
+    if (slot?.serving) {
       return slot.executor;
     }
     for (const survivor of workers.values()) {
-      if (survivor.indexes.has(indexName)) {
+      if (survivor.serving && survivor.indexes.has(indexName)) {
         return survivor.executor;
       }
     }
@@ -9706,6 +7820,7 @@ function createWorkerPool(config) {
         workerId: indices[n],
         heapUsed: toFinite(report?.heapUsed),
         heapTotal: toFinite(report?.heapTotal),
+        heapLimit: toHeapLimit(report?.heapLimit),
         external: toFinite(report?.external)
       });
     }
@@ -9728,6 +7843,57 @@ function createWorkerPool(config) {
   function getAllExecutors() {
     return [...workers.values()].map((slot) => slot.executor);
   }
+  function executorEntries() {
+    return [...workers].map(([workerId, slot]) => ({ workerId, executor: slot.executor }));
+  }
+  function executorsHolding(indexName) {
+    const holders = [];
+    for (const slot of workers.values()) {
+      if (slot.indexes.has(indexName)) holders.push(slot.executor);
+    }
+    return holders;
+  }
+  function lease(workerId, slot) {
+    slot.inFlight += 1;
+    let released = false;
+    return {
+      workerId,
+      executor: slot.executor,
+      release() {
+        if (released) return;
+        released = true;
+        slot.inFlight -= 1;
+      }
+    };
+  }
+  function leaseLeastBusy() {
+    let chosenId = -1;
+    let chosen = null;
+    for (const [workerId, slot] of workers) {
+      if (!slot.serving) continue;
+      if (chosen === null || slot.inFlight < chosen.inFlight) {
+        chosenId = workerId;
+        chosen = slot;
+      }
+      if (chosen.inFlight === 0) break;
+    }
+    return chosen === null ? null : lease(chosenId, chosen);
+  }
+  function queriesInFlight() {
+    let total = 0;
+    for (const slot of workers.values()) {
+      if (slot.serving) total += slot.inFlight;
+    }
+    return total;
+  }
+  function leaseIdle(limit) {
+    const leases = [];
+    for (const [workerId, slot] of workers) {
+      if (leases.length >= limit) break;
+      if (slot.serving && slot.inFlight === 0) leases.push(lease(workerId, slot));
+    }
+    return leases;
+  }
   function addIndexToAll(indexName) {
     if (isShutdown) {
       throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
@@ -9737,9 +7903,23 @@ function createWorkerPool(config) {
     }
     indexAssignment.set(indexName, assignSlot(indexName));
   }
+  function spawnAll() {
+    if (isShutdown) {
+      throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
+    }
+    for (let i = 0; i < workerCount; i++) ensureWorker(i);
+  }
   return {
     getExecutor,
     getAllExecutors,
+    executorEntries,
+    executorsHolding,
+    leaseLeastBusy,
+    leaseIdle,
+    queriesInFlight,
+    spawnAll,
+    deadWorkerIds,
+    spawnReplacement,
     get workerCount() {
       return workerCount;
     },
@@ -9751,6 +7931,9 @@ function createWorkerPool(config) {
   };
 }
 
+// src/workers/resource-limits.ts
+var WORKER_RESOURCE_LIMITS = { maxYoungGenerationSizeMb: WORKER_YOUNG_GENERATION_MB };
+
 // src/vector/search-pool/spawn.ts
 function resolveWorkerEntryPoint2() {
   const base = import.meta.url;
@@ -9764,7 +7947,7 @@ async function spawnWorker2(entryPoint) {
   const runtime = detectRuntime();
   if (runtime.supportsWorkerThreads) {
     try {
-      return await spawnNodeWorker(new URL(entryPoint));
+      return await spawnNodeWorker(new URL(entryPoint), WORKER_RESOURCE_LIMITS);
     } catch {
       return null;
     }
@@ -9799,8 +7982,6 @@ function listenForFailure(worker, handler) {
 }
 
 // src/vector/search-pool/index.ts
-var SEARCH_TIMEOUT_MS = 3e4;
-var LOAD_TIMEOUT_MS = 3e5;
 async function createVectorSearchPool(requestedCount) {
   const entryPoint = resolveWorkerEntryPoint2();
   const count = resolveWorkerCount(requestedCount);
@@ -9832,22 +8013,22 @@ async function createVectorSearchPool(requestedCount) {
   if (slots.length === 0) return null;
   let requestCounter = 0;
   function send(slot, key, message, timeoutMs) {
-    return new Promise((resolve, reject2) => {
+    return new Promise((resolve, reject) => {
       if (!slot.alive) {
-        reject2(new Error("Vector search worker is not running"));
+        reject(new Error("Vector search worker is not running"));
         return;
       }
       const timer = setTimeout(() => {
         slot.pending.delete(key);
-        reject2(new Error(`Vector search worker did not answer within ${timeoutMs}ms`));
+        reject(new Error(`Vector search worker did not answer within ${timeoutMs}ms`));
       }, timeoutMs);
-      slot.pending.set(key, { resolve, reject: reject2, timer });
+      slot.pending.set(key, { resolve, reject, timer });
       try {
         slot.worker.postMessage(message);
       } catch (err) {
         slot.pending.delete(key);
         clearTimeout(timer);
-        reject2(err instanceof Error ? err : new Error(String(err)));
+        reject(err instanceof Error ? err : new Error(String(err)));
       }
     });
   }
@@ -9863,7 +8044,7 @@ async function createVectorSearchPool(requestedCount) {
   async function sendSearch(slot, request) {
     slot.outstanding += 1;
     try {
-      return await send(slot, request.requestId, request, SEARCH_TIMEOUT_MS);
+      return await send(slot, request.requestId, request, VECTOR_SEARCH_TIMEOUT_MS);
     } finally {
       slot.outstanding -= 1;
     }
@@ -9880,7 +8061,7 @@ async function createVectorSearchPool(requestedCount) {
         slots.map((slot) => {
           requestCounter += 1;
           const requestId = `${requestCounter}`;
-          return send(slot, requestId, { type: "load", requestId, handle, snapshot }, LOAD_TIMEOUT_MS);
+          return send(slot, requestId, { type: "load", requestId, handle, snapshot }, VECTOR_SEARCH_LOAD_TIMEOUT_MS);
         })
       );
       return outcomes.every(
@@ -9896,7 +8077,7 @@ async function createVectorSearchPool(requestedCount) {
             slot,
             requestId,
             { type: "loadShared", requestId, handle, scratchSlot, snapshot },
-            LOAD_TIMEOUT_MS
+            VECTOR_SEARCH_LOAD_TIMEOUT_MS
           );
         })
       );
@@ -9909,7 +8090,7 @@ async function createVectorSearchPool(requestedCount) {
         slots.map((slot) => {
           requestCounter += 1;
           const requestId = `${requestCounter}`;
-          return send(slot, requestId, { type: "drop", requestId, handle }, SEARCH_TIMEOUT_MS);
+          return send(slot, requestId, { type: "drop", requestId, handle }, VECTOR_SEARCH_TIMEOUT_MS);
         })
       );
     },
@@ -9977,11 +8158,11 @@ async function createVectorSearchPool(requestedCount) {
 var sharedPool = null;
 var poolHolders = 0;
 var workersUnavailable = false;
-function acquireVectorSearchPool() {
+function acquireVectorSearchPool(requestedCount) {
   poolHolders += 1;
   if (workersUnavailable) return Promise.resolve(null);
   if (sharedPool === null) {
-    sharedPool = createVectorSearchPool().then(
+    sharedPool = createVectorSearchPool(requestedCount).then(
       (pool) => {
         if (pool === null) workersUnavailable = true;
         return pool;
@@ -10004,9 +8185,52 @@ async function releaseVectorSearchPool() {
   await pool?.shutdown();
 }
 
+// src/vector/shared-generation/doc-ids.ts
+var ABSENT_PARTITION = -1;
+function buildSharedDocIdTable(store, slots) {
+  const encoder3 = new TextEncoder();
+  const encoded = new Array(slots);
+  let totalBytes = 0;
+  for (let ordinal = 0; ordinal < slots; ordinal++) {
+    const docId = store.docIdForOrdinal(ordinal);
+    if (docId === void 0) {
+      encoded[ordinal] = null;
+      continue;
+    }
+    const bytes = encoder3.encode(docId);
+    encoded[ordinal] = bytes;
+    totalBytes += bytes.length;
+  }
+  const table = {
+    bytes: new Uint8Array(new SharedArrayBuffer(totalBytes)),
+    offsets: new Uint32Array(new SharedArrayBuffer((slots + 1) * 4)),
+    partitions: new Int32Array(new SharedArrayBuffer(slots * 4))
+  };
+  let cursor = 0;
+  for (let ordinal = 0; ordinal < slots; ordinal++) {
+    table.offsets[ordinal] = cursor;
+    const bytes = encoded[ordinal];
+    if (bytes === null) {
+      table.partitions[ordinal] = ABSENT_PARTITION;
+      continue;
+    }
+    table.bytes.set(bytes, cursor);
+    cursor += bytes.length;
+    table.partitions[ordinal] = store.partitionOfOrdinal(ordinal) ?? ABSENT_PARTITION;
+  }
+  table.offsets[slots] = cursor;
+  return table;
+}
+var decoder3 = new TextDecoder();
+function docIdAt(table, ordinal) {
+  if (ordinal < 0 || ordinal >= table.partitions.length) return void 0;
+  const start = table.offsets[ordinal];
+  const end = table.offsets[ordinal + 1];
+  if (start === end) return void 0;
+  return decoder3.decode(table.bytes.subarray(start, end));
+}
+
 // src/vector/shared-generation/layout.ts
-var WASM_PAGE_BYTES = 65536;
-var MAX_WASM_PAGES = 65536;
 var SCRATCH_ALIGNMENT = 16;
 function alignUp(bytes) {
   return Math.ceil(bytes / SCRATCH_ALIGNMENT) * SCRATCH_ALIGNMENT;
@@ -10129,13 +8353,62 @@ function invalidateWorkerCopies(state) {
   if (state.workerCopyHandle === null) return;
   const handle = state.workerCopyHandle;
   const pool = state.workerCopyPool;
+  const hosted = state.workerCopyMode === "hosted";
   state.workerCopyHandle = null;
   state.workerCopyPool = null;
   state.workerCopyRevision = -1;
   state.workerCopyMode = null;
+  if (hosted) {
+    void state.workerCopies.host?.drop(state.indexName, state.fieldName, handle).catch(() => void 0);
+    return;
+  }
   void pool?.drop(handle).catch(() => void 0);
   void releaseVectorSearchPool().catch(() => void 0);
 }
+function refreshWorkerCopies(state) {
+  invalidateWorkerCopies(state);
+  scheduleWorkerCopyLoad(state);
+}
+async function loadHostedCopy(state, host) {
+  const revision = state.revision;
+  if (!host.holdsIndex(state.indexName)) return false;
+  if (!state.store.partitionsKnown) {
+    assignStorePartitions(state, (docId) => host.resolvePartition(state.indexName, docId));
+  }
+  const shared = freezeSharedGeneration(
+    {
+      dimension: state.dimension,
+      store: state.store,
+      hnsw: state.hnsw,
+      quantizer: state.sq8,
+      quantization: state.quantizationMode
+    },
+    host.scratchSlotCount
+  );
+  if (shared === null) return false;
+  const docIds = buildSharedDocIdTable(state.store, state.store.slots);
+  handleCounter += 1;
+  const handle = `${state.indexName}/${state.fieldName}#${handleCounter}`;
+  state.workerCopyHandle = handle;
+  state.workerCopyRevision = revision;
+  state.workerCopyMode = "hosted";
+  let loaded = false;
+  try {
+    loaded = await host.loadShared(state.indexName, state.fieldName, handle, {
+      snapshot: shared,
+      docIds,
+      filterThreshold: state.filterThreshold
+    });
+  } catch {
+    loaded = false;
+  }
+  if (!loaded && state.workerCopyHandle === handle) {
+    state.workerCopyHandle = null;
+    state.workerCopyRevision = -1;
+    state.workerCopyMode = null;
+  }
+  return !state.disposed && state.revision !== revision;
+}
 function captureCloneSnapshot(state) {
   if (!state.hnsw) return null;
   return {
@@ -10148,18 +8421,27 @@ function captureCloneSnapshot(state) {
   };
 }
 function scheduleWorkerCopyLoad(state) {
+  if (!state.workerCopies.enabled) return;
   if (state.disposed || state.workerCopyLoading || state.building) return;
   if (state.workerCopyHandle !== null) return;
   if (!state.hnsw || state.buffer.size > 0) return;
-  if (liveSize(state) < WORKER_COPY_MIN_VECTORS) return;
+  const host = state.workerCopies.host;
+  if (host === void 0 && liveSize(state) < WORKER_COPY_MIN_VECTORS) return;
   state.workerCopyLoading = true;
-  void loadWorkerCopies(state).finally(() => {
-    state.workerCopyLoading = false;
-  });
+  const loading = host === void 0 ? loadWorkerCopies(state).then(() => false) : loadHostedCopy(state, host);
+  void loading.then(
+    (superseded) => {
+      state.workerCopyLoading = false;
+      if (superseded) scheduleWorkerCopyLoad(state);
+    },
+    () => {
+      state.workerCopyLoading = false;
+    }
+  );
 }
 async function loadWorkerCopies(state) {
   const revision = state.revision;
-  const pool = await acquireVectorSearchPool();
+  const pool = await acquireVectorSearchPool(state.workerCopies.count);
   if (pool === null) {
     await releaseVectorSearchPool();
     return;
@@ -10209,7 +8491,7 @@ async function loadWorkerCopies(state) {
 async function searchViaWorkerCopies(state, query, k, metric, minSimilarity, efSearch, filter) {
   const pool = state.workerCopyPool;
   const handle = state.workerCopyHandle;
-  if (pool === null || handle === null) return null;
+  if (pool === null || handle === null || state.workerCopyMode === "hosted") return null;
   if (state.workerCopyRevision !== state.revision) return null;
   try {
     if (state.workerCopyMode === "shared") {
@@ -10320,6 +8602,8 @@ function triggerBuild(state) {
       state.pendingBuild = null;
       if (state.buffer.size > 0) {
         scheduleBuild(state);
+      } else if (state.workerCopies.host !== void 0) {
+        scheduleWorkerCopyLoad(state);
       }
     }
   })();
@@ -10760,7 +9044,7 @@ function searchWithFilter(state, query, k, options, filter) {
 }
 
 // src/vector/vector-index/index.ts
-function createVectorIndex(fieldName, dimension, config) {
+function createVectorIndex(fieldName, dimension, config, workerCopies = VECTOR_WORKER_COPIES_ALLOWED, indexName = "") {
   if (!Number.isInteger(dimension) || dimension <= 0) {
     throw new NarsilError(
       ErrorCodes.VECTOR_DIMENSION_MISMATCH,
@@ -10776,6 +9060,7 @@ function createVectorIndex(fieldName, dimension, config) {
   const dimensionScale = dimension / 256;
   const store = createVectorStore();
   const state = {
+    indexName,
     fieldName,
     dimension,
     dimensionScale,
@@ -10783,6 +9068,7 @@ function createVectorIndex(fieldName, dimension, config) {
     filterThreshold,
     quantizationMode,
     hnswConfig,
+    workerCopies,
     store,
     tombstones: /* @__PURE__ */ new Set(),
     buffer: /* @__PURE__ */ new Set(),
@@ -10816,19 +9102,6 @@ function createVectorIndex(fieldName, dimension, config) {
     state.store.insert(docId, vector, partitionId);
     state.buffer.add(docId);
   }
-  function assignPartitions(resolve) {
-    for (let ordinal = 0; ordinal < state.store.slots; ordinal += 1) {
-      if (state.store.partitionOfOrdinal(ordinal) !== void 0) continue;
-      const docId = state.store.docIdForOrdinal(ordinal);
-      if (docId === void 0) continue;
-      const partitionId = resolve(docId);
-      if (partitionId === void 0) {
-        state.store.forgetPartition(docId);
-        continue;
-      }
-      state.store.setPartition(docId, partitionId);
-    }
-  }
   function remove(docId) {
     if (!state.store.has(docId)) return;
     invalidateWorkerCopies(state);
@@ -10898,12 +9171,13 @@ function createVectorIndex(fieldName, dimension, config) {
     insert,
     remove,
     partitionsKnown: () => state.store.partitionsKnown,
-    assignPartitions,
+    assignPartitions: (resolve) => assignStorePartitions(state, resolve),
     scheduleBuild: () => scheduleBuild(state),
     awaitPendingBuild,
     dispose,
     search: (query, k, options) => search(state, query, k, options),
     searchParallel,
+    refreshWorkerCopies: () => refreshWorkerCopies(state),
     getVector,
     has,
     compact: () => {
@@ -10924,9 +9198,200 @@ function createVectorIndex(fieldName, dimension, config) {
   };
 }
 
+// src/workers/segment-actions.ts
+function isSegmentAction(action) {
+  return action.type === "buildSegment" || action.type === "mergeSegments" || action.type === "attachSegments" || action.type === "compactSegments" || action.type === "swapSegments" || action.type === "freezeLiveTail";
+}
+function growPartitionsTo(manager, partitionId) {
+  while (manager.partitionCount <= partitionId) {
+    manager.addPartition();
+  }
+}
+function requireComposite(entry, indexName, partitionId, verb) {
+  const partition = entry.manager.getPartition(partitionId);
+  if (!isCompositePartition(partition)) {
+    throw new NarsilError(
+      ErrorCodes.PARTITION_CORRUPTED,
+      `Partition ${partitionId} of "${indexName}" holds no frozen segments to ${verb}`,
+      { indexName, partitionId }
+    );
+  }
+  return partition;
+}
+function runSegmentAction(entry, action) {
+  switch (action.type) {
+    case "buildSegment": {
+      const segment = createPartitionIndex(0, entry.config.trackPositions ?? true);
+      const options = resolvePartitionInsertOptions(entry.config, entry.manager.analysis, action.options);
+      segment.beginBatch();
+      for (const doc of action.documents) {
+        segment.insert(doc.docId, doc.document, entry.config.schema, entry.language, options);
+      }
+      segment.endBatch();
+      return segment.encodeSegment();
+    }
+    case "mergeSegments": {
+      for (const segment of action.segments) {
+        if (segment.payload.docIds.some((docId) => entry.manager.has(docId))) {
+          console.warn(
+            `Skipping replicated segment for index "${action.indexName}": its documents already exist on this copy`
+          );
+          continue;
+        }
+        entry.manager.mergeSegment(segment.partitionId, segment.payload, segment.documents);
+      }
+      return void 0;
+    }
+    case "attachSegments": {
+      for (const segment of action.segments) {
+        growPartitionsTo(entry.manager, segment.partitionId);
+        const frozen = createSharedFrozenSegment(segment.snapshot);
+        for (const docId of segment.tombstonedDocIds ?? []) frozen.tombstoneDocument(docId);
+        entry.manager.attachFrozenSegment(segment.partitionId, frozen);
+      }
+      return void 0;
+    }
+    case "compactSegments": {
+      const partition = requireComposite(entry, action.indexName, action.partitionId, "compact");
+      const segments = partition.frozenSegmentsById(action.segmentIds);
+      const { payload, documents } = buildCompactedSegmentPayload(segments);
+      return freezeSegmentShared(payload, documents);
+    }
+    case "swapSegments": {
+      const partition = requireComposite(entry, action.indexName, action.partitionId, "swap");
+      partition.swapFrozenSegments(action.dropSegmentIds, createSharedFrozenSegment(action.snapshot));
+      return void 0;
+    }
+    case "freezeLiveTail": {
+      growPartitionsTo(entry.manager, action.partitionId);
+      const tail = entry.manager.getPartition(action.partitionId);
+      const held = isCompositePartition(tail) ? tail.live.count() : tail.count();
+      if (held !== action.snapshot.documentCount) {
+        console.warn(
+          `Partition ${action.partitionId} of "${action.indexName}" held ${held} live documents where the frozen tail holds ${action.snapshot.documentCount}`
+        );
+      }
+      entry.manager.replaceLiveTail(action.partitionId, createSharedFrozenSegment(action.snapshot));
+      return void 0;
+    }
+  }
+}
+
+// src/vector/shared-generation/searcher.ts
+function bruteForceOrdinals(state, rankByOrdinal, query, k, metric, minSimilarity, filter) {
+  const arenaQuery = state.store.prepareQueryArena(query);
+  const queryMagnitude = arenaQuery ? arenaQuery.magnitude : magnitude(query);
+  const bestFirst = (a, b) => b.score - a.score || rankByOrdinal[a.ord] - rankByOrdinal[b.ord];
+  const heap = createBoundedMaxHeap(bestFirst, k);
+  for (const ord of ordinalFilterValues(filter)) {
+    if (ord >= rankByOrdinal.length || state.tombstones[ord] === 1) continue;
+    let distance;
+    if (arenaQuery) {
+      distance = state.store.distanceFromArena(arenaQuery, ord, metric);
+      if (distance === Number.POSITIVE_INFINITY) continue;
+    } else {
+      const entry = entryForOrd(state, ord);
+      if (!entry) continue;
+      distance = toDistance(query, entry.vector, queryMagnitude, entry.magnitude, metric);
+    }
+    const score = toScore(distance, metric);
+    if (score >= minSimilarity) heap.push({ ord, score });
+  }
+  return heap.toSortedArray().reverse();
+}
+function ordinalsByDocId(docIds) {
+  const ordinals = /* @__PURE__ */ new Map();
+  for (let ordinal = 0; ordinal < docIds.partitions.length; ordinal++) {
+    const docId = docIdAt(docIds, ordinal);
+    if (docId !== void 0) ordinals.set(docId, ordinal);
+  }
+  return ordinals;
+}
+function createSharedVectorSearcher(options) {
+  const { fieldName, snapshot, scratchSlot, docIds, holdsDocument } = options;
+  const filterThreshold = options.filterThreshold ?? DEFAULT_FILTER_THRESHOLD;
+  const copy = openSharedWorkerCopy(snapshot, scratchSlot);
+  const slots = docIds.partitions.length;
+  let ordinalIndex = null;
+  function hitsFor(query, k, searchOptions, filter) {
+    const { metric, minSimilarity, efSearch } = searchOptions;
+    const liveSize2 = copy.searchState.nodeCount - copy.searchState.tombstoneCount;
+    if (filter !== void 0 && liveSize2 > 0 && filter.count / liveSize2 < filterThreshold) {
+      return bruteForceOrdinals(copy.searchState, copy.rankByOrdinal, query, k, metric, minSimilarity, filter);
+    }
+    return searchOrdinals(copy.searchState, query, k, metric, minSimilarity, copy.rankByOrdinal, filter, efSearch);
+  }
+  function filterForDocIds(allowed) {
+    if (ordinalIndex === null) ordinalIndex = ordinalsByDocId(docIds);
+    const filter = createOrdinalFilter(slots);
+    for (const docId of allowed) {
+      const ordinal = ordinalIndex.get(docId);
+      if (ordinal !== void 0) addToOrdinalFilter(filter, ordinal);
+    }
+    return filter;
+  }
+  function filterForPartitions(allowed) {
+    const filter = createOrdinalFilter(slots);
+    for (let ordinal = 0; ordinal < slots; ordinal++) {
+      if (allowed.has(docIds.partitions[ordinal])) addToOrdinalFilter(filter, ordinal);
+    }
+    return filter;
+  }
+  function filterFor(searchOptions) {
+    if (searchOptions.filterDocIds !== void 0) return filterForDocIds(searchOptions.filterDocIds);
+    if (searchOptions.filterPartitions !== void 0) return filterForPartitions(searchOptions.filterPartitions);
+    return void 0;
+  }
+  return {
+    fieldName,
+    dimension: snapshot.dimension,
+    partitionsKnown: () => true,
+    assignPartitions: () => void 0,
+    searchParallel(query, k, searchOptions) {
+      const filter = filterFor(searchOptions);
+      if (filter !== void 0 && filter.count === 0) return Promise.resolve([]);
+      const hits = hitsFor(query, k, searchOptions, filter);
+      const results = [];
+      for (const hit of hits) {
+        const docId = docIdAt(docIds, hit.ord);
+        if (docId === void 0 || !holdsDocument(docId)) continue;
+        results.push({ docId, score: hit.score });
+      }
+      return Promise.resolve(results);
+    }
+  };
+}
+
+// src/workers/vector-copies.ts
+function createHeldVectorCopies() {
+  return { searchers: /* @__PURE__ */ new Map(), handles: /* @__PURE__ */ new Map() };
+}
+function loadHeldVectorCopy(held, manager, fieldName, handle, copy, scratchSlot) {
+  held.searchers.set(
+    fieldName,
+    createSharedVectorSearcher({
+      fieldName,
+      snapshot: copy.snapshot,
+      scratchSlot,
+      docIds: copy.docIds,
+      filterThreshold: copy.filterThreshold,
+      holdsDocument: (docId) => manager.has(docId)
+    })
+  );
+  held.handles.set(fieldName, handle);
+}
+function dropHeldVectorCopy(held, fieldName, handle) {
+  if (held.handles.get(fieldName) !== handle) return;
+  held.searchers.delete(fieldName);
+  held.handles.delete(fieldName);
+}
+
 // src/workers/direct-executor.ts
-function createDirectExecutor() {
+var NO_VECTOR_WORKER_COPIES = { enabled: false };
+function createDirectExecutor(options) {
   const indexes = /* @__PURE__ */ new Map();
+  const vectorWorkerCopies = options?.vectorWorkerCopies ?? NO_VECTOR_WORKER_COPIES;
+  const scratchSlot = options?.scratchSlot ?? 0;
   function requireIndex(indexName) {
     const entry = indexes.get(indexName);
     if (!entry) {
@@ -10936,7 +9401,17 @@ function createDirectExecutor() {
     }
     return entry;
   }
-  function createIndex(indexName, config, language) {
+  function vectorIndexesFor(indexName, config) {
+    const vectorIndexes = /* @__PURE__ */ new Map();
+    for (const [fieldPath, dim] of extractVectorFieldsFromSchema(config.schema)) {
+      vectorIndexes.set(
+        fieldPath,
+        createVectorIndex(fieldPath, dim, config.vectorPromotion, vectorWorkerCopies, indexName)
+      );
+    }
+    return vectorIndexes;
+  }
+  function createIndex(indexName, config, language, analysisStale = false) {
     if (indexes.has(indexName)) {
       throw new NarsilError(ErrorCodes.INDEX_ALREADY_EXISTS, `Index "${indexName}" already exists`, {
         indexName
@@ -10944,11 +9419,7 @@ function createDirectExecutor() {
     }
     const router = createPartitionRouter();
     const partitionCount = config.partitions?.maxPartitions ?? 1;
-    const vectorFields = extractVectorFieldsFromSchema(config.schema);
-    const vectorIndexes = /* @__PURE__ */ new Map();
-    for (const [fieldPath, dim] of vectorFields) {
-      vectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dim, config.vectorPromotion));
-    }
+    const vectorIndexes = vectorIndexesFor(indexName, config);
     const manager = createPartitionManager(indexName, config, language, router, partitionCount, vectorIndexes);
     indexes.set(indexName, {
       manager,
@@ -10959,7 +9430,9 @@ function createDirectExecutor() {
         stopWords: manager.analysis.stopWords,
         customTokenizer: manager.analysis.customTokenizer
       },
-      vectorIndexes
+      vectorIndexes,
+      vectorCopies: createHeldVectorCopies(),
+      analysisStale
     });
   }
   function dropIndex(indexName) {
@@ -10978,7 +9451,21 @@ function createDirectExecutor() {
   function getManager(indexName) {
     return indexes.get(indexName)?.manager;
   }
+  function queryContextOf(indexName) {
+    const entry = indexes.get(indexName);
+    if (entry === void 0) return void 0;
+    return {
+      manager: entry.manager,
+      config: entry.config,
+      language: entry.language,
+      vectorSearchers: entry.vectorCopies.searchers,
+      analysisStale: entry.analysisStale
+    };
+  }
   async function execute(action) {
+    if (isSegmentAction(action)) {
+      return runSegmentAction(requireIndex(action.indexName), action);
+    }
     switch (action.type) {
       case "bootstrap": {
         throw new NarsilError(
@@ -10987,79 +9474,35 @@ function createDirectExecutor() {
           { moduleUrl: action.moduleUrl }
         );
       }
+      case "serveRequests":
+      case "stopServing": {
+        throw new NarsilError(
+          ErrorCodes.CONFIG_INVALID,
+          "Only a worker thread serves requests, and the thread that owns this executor receives them itself"
+        );
+      }
       case "createIndex": {
         const language = getLanguage(action.config.language ?? "english");
-        createIndex(action.indexName, action.config, language);
+        createIndex(action.indexName, action.config, language, action.analysisStale ?? false);
         return void 0;
       }
       case "dropIndex": {
         dropIndex(action.indexName);
         return void 0;
       }
-      case "insert": {
-        const entry = requireIndex(action.indexName);
-        entry.manager.insert(action.docId, action.document, action.skipClone ? { skipClone: true } : void 0);
-        return void 0;
-      }
-      case "buildSegment": {
-        const entry = requireIndex(action.indexName);
-        const segment = createPartitionIndex(0, entry.config.trackPositions ?? true);
-        const options = resolvePartitionInsertOptions(entry.config, entry.manager.analysis, action.options);
-        segment.beginBatch();
-        for (const doc of action.documents) {
-          segment.insert(doc.docId, doc.document, entry.config.schema, entry.language, options);
-        }
-        segment.endBatch();
-        return segment.encodeSegment();
-      }
-      case "mergeSegments": {
+      case "loadVectorCopy": {
         const entry = requireIndex(action.indexName);
-        for (const segment of action.segments) {
-          if (segment.payload.docIds.some((docId) => entry.manager.has(docId))) {
-            console.warn(
-              `Skipping replicated segment for index "${action.indexName}": its documents already exist on this copy`
-            );
-            continue;
-          }
-          entry.manager.mergeSegment(segment.partitionId, segment.payload, segment.documents);
-        }
+        loadHeldVectorCopy(entry.vectorCopies, entry.manager, action.fieldName, action.handle, action.copy, scratchSlot);
         return void 0;
       }
-      case "attachSegments": {
-        const entry = requireIndex(action.indexName);
-        for (const segment of action.segments) {
-          while (entry.manager.partitionCount <= segment.partitionId) {
-            entry.manager.addPartition();
-          }
-          entry.manager.attachFrozenSegment(segment.partitionId, createSharedFrozenSegment(segment.snapshot));
-        }
+      case "dropVectorCopy": {
+        const entry = indexes.get(action.indexName);
+        if (entry !== void 0) dropHeldVectorCopy(entry.vectorCopies, action.fieldName, action.handle);
         return void 0;
       }
-      case "compactSegments": {
-        const entry = requireIndex(action.indexName);
-        const partition = entry.manager.getPartition(action.partitionId);
-        if (!isCompositePartition(partition)) {
-          throw new NarsilError(
-            ErrorCodes.PARTITION_CORRUPTED,
-            `Partition ${action.partitionId} of "${action.indexName}" holds no frozen segments to compact`,
-            { indexName: action.indexName, partitionId: action.partitionId }
-          );
-        }
-        const segments = partition.frozenSegmentsById(action.segmentIds);
-        const { payload, documents } = buildCompactedSegmentPayload(segments);
-        return freezeSegmentShared(payload, documents);
-      }
-      case "swapSegments": {
+      case "insert": {
         const entry = requireIndex(action.indexName);
-        const partition = entry.manager.getPartition(action.partitionId);
-        if (!isCompositePartition(partition)) {
-          throw new NarsilError(
-            ErrorCodes.PARTITION_CORRUPTED,
-            `Partition ${action.partitionId} of "${action.indexName}" holds no frozen segments to swap`,
-            { indexName: action.indexName, partitionId: action.partitionId }
-          );
-        }
-        partition.swapFrozenSegments(action.dropSegmentIds, createSharedFrozenSegment(action.snapshot));
+        entry.manager.insert(action.docId, action.document, action.skipClone ? { skipClone: true } : void 0);
         return void 0;
       }
       case "remove": {
@@ -11134,13 +9577,9 @@ function createDirectExecutor() {
           partition.clear();
         }
         entry.manager.setPartitions(partitions);
-        const vectorFields = extractVectorFieldsFromSchema(entry.config.schema);
-        const newVectorIndexes = /* @__PURE__ */ new Map();
-        for (const [fieldPath, dim] of vectorFields) {
-          newVectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dim, entry.config.vectorPromotion));
-        }
-        entry.manager.resetVectorIndexes(newVectorIndexes);
+        entry.manager.resetVectorIndexes(vectorIndexesFor(action.indexName, entry.config));
         entry.vectorIndexes = entry.manager.getVectorIndexes();
+        entry.vectorCopies = createHeldVectorCopies();
         return void 0;
       }
       case "serialize": {
@@ -11149,15 +9588,13 @@ function createDirectExecutor() {
       }
       case "deserialize": {
         const entry = requireIndex(action.indexName);
-        while (entry.manager.partitionCount <= action.partitionId) {
-          entry.manager.addPartition();
-        }
+        growPartitionsTo(entry.manager, action.partitionId);
         entry.manager.deserializePartition(action.partitionId, action.data);
         return void 0;
       }
       case "memoryReport": {
-        const report = typeof process !== "undefined" && process.memoryUsage ? process.memoryUsage() : {};
-        return report;
+        const usage = typeof process !== "undefined" && process.memoryUsage ? process.memoryUsage() : {};
+        return { ...usage, heapLimit: readHeapStatistics()?.limitBytes ?? null };
       }
       case "shutdown": {
         for (const [, entry] of indexes) {
@@ -11177,10 +9614,11 @@ function createDirectExecutor() {
     execute,
     shutdown,
     getManager,
+    queryContextOf,
     createIndex,
     dropIndex,
     listIndexes
   };
 }
 
-export { DEFAULT_PAGE_SIZE, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, MAX_NESTING_DEPTH, RESULT_WINDOW, applyPagination, applyProjection, applySorting, buildCompactedSegmentPayload, clampRowCount, clearNormalizationCache, collectQueryTermStats, configureNormalizationCache, countsWithoutScores, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, createVectorIndex, createWorkerPool, decodePageCursor, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, detectRuntime, encodePageCursor, extractVectorFieldsFromSchema, fanOutMatchCount, fanOutQuery, flattenSchema, fnv1a, fnv1aBytes, freezeSegmentShared, fulltextMatches, getLanguage, getNestedValue, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, isTextFieldType, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, partitionsIn, pruneStatsToQueryTerms, readSortValues, registerLanguage, registerStopWords, registerTokenizer, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveIndexAnalysis, resolveProjection, serializeMetadata, sortSignatureOf, spawnNodeWorker, tokenize, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion };
+export { CHECKSUM_TIMEOUT_MS, CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, SHUTDOWN_TIMEOUT_MS, WORKER_RESOURCE_LIMITS, buildCompactedSegmentPayload, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, createVectorIndex, createWorkerPool, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getLanguage, getNestedValue, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, readHeapStatistics, registerLanguage, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolveRequestThreadCount, resolveWorkerCount, serializeMetadata, spawnNodeWorker, splitWorkerBudget };