@delali/narsil 0.1.0

package/dist/chunk-5HXMVMSM.mjs

@@ -0,0 +1,3147 @@
+import { english } from './chunk-WYC635GI.mjs';
+import { NarsilError, ErrorCodes } from './chunk-JKIBUPAY.mjs';
+
+// 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/search/facets.ts
+function mergeFacets(partitionFacets) {
+  const merged = /* @__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);
+      }
+      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 };
+  }
+  return result;
+}
+
+// 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/tokenizer.ts
+var DEFAULT_SPLIT_PATTERN = /[^\p{L}\p{N}_'-]+/u;
+var DEFAULT_MIN_TOKEN_LENGTH = 1;
+var normalizationCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 65536;
+function stripDiacritics(text) {
+  return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function resolveStopWords(language, override) {
+  if (!override) return language.stopWords;
+  if (override instanceof Set) return override;
+  return override(language.stopWords);
+}
+function transformToken(raw, language, stem, removeDiacritics) {
+  const flags = (stem ? "s" : "") + (removeDiacritics ? "d" : "");
+  const cacheKey = `${language.name}:${flags}:${raw}`;
+  const cached = normalizationCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  let normalized = raw;
+  if (removeDiacritics) {
+    normalized = stripDiacritics(normalized);
+  }
+  if (stem && language.stemmer) {
+    normalized = language.stemmer(normalized);
+  }
+  cacheAndReturn(cacheKey, normalized);
+  return normalized;
+}
+function cacheAndReturn(key, value) {
+  if (normalizationCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = normalizationCache.keys().next().value;
+    normalizationCache.delete(firstKey);
+  }
+  normalizationCache.set(key, value);
+}
+function splitText(text, language) {
+  const pattern = language.tokenizer?.splitPattern ?? DEFAULT_SPLIT_PATTERN;
+  return text.split(pattern);
+}
+function tokenize(text, language, options) {
+  const {
+    stem = true,
+    removeStopWords = true,
+    removeDiacritics = false,
+    customTokenizer,
+    stopWordOverride
+  } = options ?? {};
+  if (customTokenizer) {
+    const customResult = customTokenizer.tokenize(text);
+    return {
+      tokens: customResult,
+      originalTokens: customResult.map((t) => t.token)
+    };
+  }
+  const normalized = text.normalize("NFC").toLowerCase();
+  const rawParts = splitText(normalized, language);
+  const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
+  const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
+  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
+  const tokens = [];
+  const originalTokens = [];
+  let position = 0;
+  for (const part of rawParts) {
+    if (part.length < minLength) {
+      position++;
+      continue;
+    }
+    if (stopWords.has(part)) {
+      position++;
+      continue;
+    }
+    const processed = transformToken(part, language, stem, effectiveDiacritics);
+    if (processed.length > 0) {
+      tokens.push({ token: processed, position });
+      originalTokens.push(part);
+    }
+    position++;
+  }
+  return { tokens, originalTokens };
+}
+
+// src/schema/validator.ts
+var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "enum",
+  "geopoint",
+  "string[]",
+  "number[]",
+  "boolean[]",
+  "enum[]"
+]);
+var VECTOR_PATTERN = /^vector\[(\d+)]$/;
+var RESERVED_ROOT_FIELDS = /* @__PURE__ */ new Set(["id"]);
+var MAX_NESTING_DEPTH = 4;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 (depth === 1 && RESERVED_ROOT_FIELDS.has(field)) {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${field}" is reserved and cannot be defined in a schema`,
+        { field, path }
+      );
+    }
+    if (isPlainObject(type)) {
+      validateSchemaFields(type, depth + 1, path);
+      continue;
+    }
+    if (typeof type !== "string") {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${path}" has an invalid type definition: ${String(type)}`,
+        {
+          field: path,
+          type: String(type)
+        }
+      );
+    }
+    if (SCALAR_FIELD_TYPES.has(type)) continue;
+    const vectorMatch = VECTOR_PATTERN.exec(type);
+    if (vectorMatch) {
+      const dimension = Number.parseInt(vectorMatch[1], 10);
+      if (dimension <= 0) {
+        throw new NarsilError(
+          ErrorCodes.SCHEMA_INVALID_VECTOR_DIMENSION,
+          `Vector field "${path}" must have a positive dimension, got ${dimension}`,
+          { field: path, dimension }
+        );
+      }
+      continue;
+    }
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field "${path}" has an unsupported type: "${type}"`, {
+      field: path,
+      type
+    });
+  }
+}
+function validateSchema(schema) {
+  if (!isPlainObject(schema)) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must be a plain object", {
+      received: typeof schema
+    });
+  }
+  if (Object.keys(schema).length === 0) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
+  }
+  validateSchemaFields(schema, 1, "");
+}
+function 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":
+      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 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
+    });
+  }
+  validateDocumentFields(document, schema, "");
+}
+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;
+}
+
+// src/search/fulltext.ts
+function fulltextSearch(partition, params, language, schema, options) {
+  if (!params.term || params.term.trim().length === 0) {
+    return { scored: [], totalMatched: 0 };
+  }
+  if (params.fields && params.fields.length === 0) {
+    return { scored: [], totalMatched: 0 };
+  }
+  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 { scored: [], totalMatched: 0 };
+  }
+  const queryTokens = deduplicateTokens(queryTokenResult.tokens);
+  const rawResult = partition.searchFulltext({
+    queryTokens,
+    fields: params.fields,
+    boost: params.boost,
+    tolerance: params.tolerance ?? 0,
+    prefixLength: params.prefixLength ?? 2,
+    exact: params.exact ?? false,
+    bm25Params: options?.bm25Params,
+    globalStats: options?.globalStats
+  });
+  let scored = rawResult.scored;
+  const termMatch = params.termMatch ?? "any";
+  if (termMatch !== "any") {
+    scored = filterByTermCoverage(scored, queryTokens, termMatch, params.tolerance ?? 0, params.exact ?? false);
+  }
+  if (params.minScore !== void 0 && params.minScore > 0) {
+    const threshold = params.minScore;
+    scored = scored.filter((doc) => doc.score >= threshold);
+  }
+  if (params.filters) {
+    const matchingDocIds = partition.applyFilters(params.filters, schema);
+    scored = scored.filter((doc) => matchingDocIds.has(doc.docId));
+  }
+  return { scored, totalMatched: scored.length };
+}
+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 (fieldType !== "string" && 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) {
+  const requiredCount = policy === "all" ? queryTokens.length : policy;
+  if (requiredCount <= 0) return scored;
+  if (requiredCount > queryTokens.length) return [];
+  return scored.filter((doc) => {
+    const matched = countDocTermMatches(doc, queryTokens, tolerance, exact);
+    return matched >= requiredCount;
+  });
+}
+function countDocTermMatches(doc, queryTokens, tolerance, exact) {
+  const indexTokens = Object.keys(doc.idf);
+  if (indexTokens.length === 0) return 0;
+  let count = 0;
+  for (const qt of queryTokens) {
+    if (queryTermSatisfied(qt.token, indexTokens, tolerance, exact)) {
+      count++;
+    }
+  }
+  return count;
+}
+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/search/hybrid.ts
+function hybridSearch(partition, params, language, schema, options) {
+  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
+  const hasVector = params.vector !== void 0;
+  if (!hasTerm && !hasVector) {
+    return { scored: [], totalMatched: 0 };
+  }
+  if (hasTerm && !hasVector) {
+    return fulltextSearch(partition, params, language, schema, options);
+  }
+  if (!hasTerm && hasVector) {
+    return runVectorOnly(partition, params);
+  }
+  const textResult = fulltextSearch(partition, params, language, schema, options);
+  const vectorConfig = params.vector;
+  const vectorResult = partition.searchVector({
+    field: vectorConfig.field,
+    value: vectorConfig.value,
+    k: params.limit ?? 10,
+    similarity: vectorConfig.similarity,
+    metric: vectorConfig.metric
+  });
+  const normalizedText = normalizeScores(textResult.scored);
+  const normalizedVector = normalizeScores(vectorResult.scored);
+  const textDocMap = /* @__PURE__ */ new Map();
+  for (const doc of textResult.scored) {
+    textDocMap.set(doc.docId, doc);
+  }
+  const mergedMap = /* @__PURE__ */ new Map();
+  for (const doc of normalizedText) {
+    mergedMap.set(doc.docId, {
+      textScore: doc.score,
+      vectorScore: 0,
+      textDoc: textDocMap.get(doc.docId) ?? null
+    });
+  }
+  for (const doc of normalizedVector) {
+    const existing = mergedMap.get(doc.docId);
+    if (existing) {
+      existing.vectorScore = doc.score;
+    } else {
+      mergedMap.set(doc.docId, { textScore: 0, vectorScore: doc.score, textDoc: null });
+    }
+  }
+  const alpha = clampAlpha(params.hybrid?.alpha);
+  const scored = [];
+  for (const [docId, entry] of mergedMap) {
+    const combinedScore = alpha * entry.vectorScore + (1 - alpha) * entry.textScore;
+    scored.push({
+      docId,
+      score: combinedScore,
+      termFrequencies: entry.textDoc?.termFrequencies ?? {},
+      fieldLengths: entry.textDoc?.fieldLengths ?? {},
+      idf: entry.textDoc?.idf ?? {}
+    });
+  }
+  scored.sort((a, b) => b.score - a.score || a.docId.localeCompare(b.docId));
+  let filtered = scored;
+  if (params.minScore !== void 0 && params.minScore > 0) {
+    const threshold = params.minScore;
+    filtered = filtered.filter((doc) => doc.score >= threshold);
+  }
+  if (params.filters) {
+    const matchingDocIds = partition.applyFilters(params.filters, schema);
+    filtered = filtered.filter((doc) => matchingDocIds.has(doc.docId));
+  }
+  return { scored: filtered, totalMatched: filtered.length };
+}
+function runVectorOnly(partition, params) {
+  const vectorConfig = params.vector;
+  const result = partition.searchVector({
+    field: vectorConfig.field,
+    value: vectorConfig.value,
+    k: params.limit ?? 10,
+    similarity: vectorConfig.similarity,
+    metric: vectorConfig.metric
+  });
+  return result;
+}
+function normalizeScores(docs) {
+  if (docs.length === 0) return [];
+  let min = docs[0].score;
+  let max = docs[0].score;
+  for (let i = 1; i < docs.length; i++) {
+    if (docs[i].score < min) min = docs[i].score;
+    if (docs[i].score > max) max = docs[i].score;
+  }
+  const range = max - min;
+  if (range === 0) {
+    return docs.map((d) => ({ docId: d.docId, score: 1 }));
+  }
+  return docs.map((d) => ({ docId: d.docId, score: (d.score - min) / range }));
+}
+function clampAlpha(alpha) {
+  if (alpha === void 0) return 0.5;
+  if (!Number.isFinite(alpha)) return 0.5;
+  if (alpha < 0) return 0;
+  if (alpha > 1) return 1;
+  return alpha;
+}
+
+// src/partitioning/distributed-scoring.ts
+function collectGlobalStats(manager) {
+  const aggregate = manager.getAggregateStats();
+  const averageFieldLengths = {};
+  if (aggregate.totalDocuments > 0) {
+    for (const [field, totalLength] of Object.entries(aggregate.totalFieldLengths)) {
+      averageFieldLengths[field] = totalLength / aggregate.totalDocuments;
+    }
+  }
+  return {
+    totalDocuments: aggregate.totalDocuments,
+    docFrequencies: aggregate.docFrequencies,
+    totalFieldLengths: aggregate.totalFieldLengths,
+    averageFieldLengths
+  };
+}
+
+// src/partitioning/fan-out.ts
+function fanOutQuery(manager, params, language, schema, config, searchOptions) {
+  const partitions = manager.getAllPartitions();
+  if (partitions.length === 0) {
+    return { scored: [], totalMatched: 0 };
+  }
+  let globalStats;
+  const effectiveMode = resolveEffectiveMode(config);
+  if (effectiveMode === "dfs") {
+    globalStats = collectGlobalStats(manager);
+  } else if (effectiveMode === "broadcast") {
+    globalStats = config.globalStats;
+  }
+  const options = buildSearchOptions(searchOptions, globalStats);
+  const outcomes = dispatchToAllPartitions(partitions, params, language, schema, options);
+  const allScoredArrays = outcomes.map((o) => o.result.scored);
+  const merged = kWayMerge(allScoredArrays);
+  let totalMatched = 0;
+  for (const outcome of outcomes) {
+    totalMatched += outcome.result.totalMatched;
+  }
+  let facets;
+  if (params.facets) {
+    facets = collectAndMergeFacets(outcomes, params, schema);
+  }
+  return { scored: merged, totalMatched, facets };
+}
+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 dispatchToAllPartitions(partitions, params, language, schema, options) {
+  const outcomes = [];
+  for (const partition of partitions) {
+    const result = dispatchSinglePartition(partition, params, language, schema, options);
+    outcomes.push({ result, partition });
+  }
+  return outcomes;
+}
+function dispatchSinglePartition(partition, params, language, schema, options) {
+  const isHybridMode = params.mode === "hybrid";
+  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
+  const hasVector = params.vector !== void 0;
+  if (isHybridMode || hasTerm && hasVector) {
+    return hybridSearch(partition, params, language, schema, options);
+  }
+  if (params.mode === "vector" || hasVector && !hasTerm) {
+    if (!params.vector) return { scored: [], totalMatched: 0 };
+    const vectorConfig = params.vector;
+    return partition.searchVector({
+      field: vectorConfig.field,
+      value: vectorConfig.value,
+      k: params.limit ?? 10,
+      similarity: vectorConfig.similarity,
+      metric: vectorConfig.metric
+    });
+  }
+  return fulltextSearch(partition, params, language, schema, options);
+}
+function collectAndMergeFacets(outcomes, params, schema) {
+  const partitionFacets = [];
+  for (const outcome of outcomes) {
+    const matchingDocIds = new Set(outcome.result.scored.map((doc) => doc.docId));
+    if (!params.facets) continue;
+    const facetResult = outcome.partition.computeFacets(matchingDocIds, params.facets, schema);
+    partitionFacets.push(facetResult);
+  }
+  return mergeFacets(partitionFacets);
+}
+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 && a[ai].docId <= b[bi].docId) {
+      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 a.docId < b.docId;
+}
+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/document-store.ts
+function createDocumentStore() {
+  const docs = /* @__PURE__ */ new Map();
+  return {
+    store(docId, document, fieldLengths) {
+      docs.set(docId, { fields: structuredClone(document), fieldLengths });
+    },
+    get(docId) {
+      return docs.get(docId);
+    },
+    remove(docId) {
+      return docs.delete(docId);
+    },
+    has(docId) {
+      return docs.has(docId);
+    },
+    count() {
+      return docs.size;
+    },
+    all() {
+      return docs.entries();
+    },
+    clear() {
+      docs.clear();
+    },
+    serialize() {
+      const result = {};
+      for (const [docId, stored] of docs) {
+        result[docId] = stored;
+      }
+      return result;
+    },
+    deserialize(data) {
+      docs.clear();
+      for (const docId of Object.keys(data)) {
+        docs.set(docId, data[docId]);
+      }
+    }
+  };
+}
+
+// src/core/inverted-index.ts
+function createInvertedIndex() {
+  const index = /* @__PURE__ */ new Map();
+  const charBuckets = /* @__PURE__ */ new Map();
+  function trackToken(token) {
+    if (token.length === 0) return;
+    const ch = token[0];
+    let bucket = charBuckets.get(ch);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      charBuckets.set(ch, bucket);
+    }
+    bucket.add(token);
+  }
+  function untrackToken(token) {
+    if (token.length === 0) return;
+    const ch = token[0];
+    const bucket = charBuckets.get(ch);
+    if (bucket) {
+      bucket.delete(token);
+      if (bucket.size === 0) charBuckets.delete(ch);
+    }
+  }
+  function candidatesForPrefix(queryToken, prefixLength) {
+    if (prefixLength <= 0 || queryToken.length < prefixLength) {
+      return index.keys();
+    }
+    const firstChar = queryToken[0];
+    const bucket = charBuckets.get(firstChar);
+    if (!bucket) return [];
+    if (prefixLength === 1) return bucket;
+    const prefix = queryToken.slice(0, prefixLength);
+    const filtered = [];
+    for (const t of bucket) {
+      if (t.length >= prefixLength && t.startsWith(prefix)) {
+        filtered.push(t);
+      }
+    }
+    return filtered;
+  }
+  return {
+    insert(token, entry) {
+      let list = index.get(token);
+      if (!list) {
+        list = { docFrequency: 0, postings: [] };
+        index.set(token, list);
+        trackToken(token);
+      }
+      const dupeIdx = list.postings.findIndex((p) => p.docId === entry.docId && p.fieldName === entry.fieldName);
+      if (dupeIdx !== -1) {
+        list.postings[dupeIdx] = entry;
+        return;
+      }
+      const isNewDoc = !list.postings.some((p) => p.docId === entry.docId);
+      list.postings.push(entry);
+      if (isNewDoc) list.docFrequency++;
+    },
+    remove(token, docId) {
+      const list = index.get(token);
+      if (!list) return;
+      const lengthBefore = list.postings.length;
+      list.postings = list.postings.filter((p) => p.docId !== docId);
+      const removed = lengthBefore - list.postings.length;
+      if (removed > 0) list.docFrequency--;
+      if (list.postings.length === 0) {
+        index.delete(token);
+        untrackToken(token);
+      }
+    },
+    lookup(token) {
+      return index.get(token);
+    },
+    fuzzyLookup(token, tolerance, prefixLength) {
+      if (tolerance === 0) {
+        const exact = index.get(token);
+        return exact ? [{ token, postingList: exact }] : [];
+      }
+      const results = [];
+      const candidates = candidatesForPrefix(token, prefixLength);
+      for (const candidate of candidates) {
+        const { withinTolerance } = boundedLevenshtein(token, candidate, tolerance);
+        if (withinTolerance) {
+          const postingList = index.get(candidate);
+          if (postingList) results.push({ token: candidate, postingList });
+        }
+      }
+      return results;
+    },
+    has(token) {
+      return index.has(token);
+    },
+    tokens() {
+      return index.keys();
+    },
+    size() {
+      return index.size;
+    },
+    clear() {
+      index.clear();
+      charBuckets.clear();
+    },
+    serialize() {
+      const result = /* @__PURE__ */ Object.create(null);
+      for (const [token, list] of index) {
+        result[token] = list;
+      }
+      return result;
+    },
+    deserialize(data) {
+      index.clear();
+      charBuckets.clear();
+      for (const token of Object.keys(data)) {
+        index.set(token, data[token]);
+        trackToken(token);
+      }
+    }
+  };
+}
+
+// src/core/statistics.ts
+function collectUniqueTokens(tokens) {
+  const unique = /* @__PURE__ */ new Set();
+  const fields = Object.keys(tokens);
+  for (let i = 0; i < fields.length; i++) {
+    const fieldTokens = tokens[fields[i]];
+    for (let j = 0; j < fieldTokens.length; j++) {
+      unique.add(fieldTokens[j]);
+    }
+  }
+  return unique;
+}
+function createPartitionStats() {
+  const stats = {
+    totalDocuments: 0,
+    totalFieldLengths: {},
+    averageFieldLengths: {},
+    docFrequencies: {},
+    addDocument(fieldLengths, tokens) {
+      stats.totalDocuments++;
+      const fields = Object.keys(fieldLengths);
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        stats.totalFieldLengths[field] = (stats.totalFieldLengths[field] ?? 0) + fieldLengths[field];
+      }
+      const uniqueTokens = collectUniqueTokens(tokens);
+      for (const token of uniqueTokens) {
+        stats.docFrequencies[token] = (stats.docFrequencies[token] ?? 0) + 1;
+      }
+      stats.recalculateAverages();
+    },
+    removeDocument(fieldLengths, tokens) {
+      if (stats.totalDocuments === 0) return;
+      stats.totalDocuments--;
+      const fields = Object.keys(fieldLengths);
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        if (field in stats.totalFieldLengths) {
+          stats.totalFieldLengths[field] -= fieldLengths[field];
+          if (stats.totalFieldLengths[field] <= 0) {
+            delete stats.totalFieldLengths[field];
+          }
+        }
+      }
+      const uniqueTokens = collectUniqueTokens(tokens);
+      for (const token of uniqueTokens) {
+        if (token in stats.docFrequencies) {
+          stats.docFrequencies[token]--;
+          if (stats.docFrequencies[token] <= 0) {
+            delete stats.docFrequencies[token];
+          }
+        }
+      }
+      stats.recalculateAverages();
+    },
+    recalculateAverages() {
+      const fields = Object.keys(stats.totalFieldLengths);
+      const newAverages = {};
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        newAverages[field] = stats.totalDocuments > 0 ? stats.totalFieldLengths[field] / stats.totalDocuments : 0;
+      }
+      stats.averageFieldLengths = newAverages;
+    },
+    serialize() {
+      return {
+        totalDocuments: stats.totalDocuments,
+        totalFieldLengths: { ...stats.totalFieldLengths },
+        averageFieldLengths: { ...stats.averageFieldLengths },
+        docFrequencies: { ...stats.docFrequencies }
+      };
+    },
+    deserialize(data) {
+      stats.totalDocuments = data.totalDocuments;
+      stats.totalFieldLengths = { ...data.totalFieldLengths };
+      stats.averageFieldLengths = { ...data.averageFieldLengths };
+      stats.docFrequencies = { ...data.docFrequencies };
+    }
+  };
+  return stats;
+}
+
+// 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;
+  const deltaPhi = (lat2 - lat1) * DEG_TO_RAD;
+  const deltaLambda = (lon2 - lon1) * DEG_TO_RAD;
+  const halfDeltaPhi = Math.sin(deltaPhi / 2);
+  const halfDeltaLambda = Math.sin(deltaLambda / 2);
+  const a = halfDeltaPhi * halfDeltaPhi + Math.cos(phi1) * Math.cos(phi2) * halfDeltaLambda * halfDeltaLambda;
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return EARTH_RADIUS_METERS * c;
+}
+
+// src/geo/polygon.ts
+function isPointInPolygon(lat, lon, polygon) {
+  if (polygon.length < 3) return false;
+  let inside = false;
+  const n = polygon.length;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const lonI = polygon[i].lon;
+    const latI = polygon[i].lat;
+    const lonJ = polygon[j].lon;
+    const latJ = polygon[j].lat;
+    if (lonI > lon !== lonJ > lon) {
+      const slope = (latJ - latI) / (lonJ - lonI);
+      const intersectLat = latI + slope * (lon - lonI);
+      if (lat < intersectLat) {
+        inside = !inside;
+      }
+    }
+  }
+  return inside;
+}
+
+// src/geo/vincenty.ts
+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 U1 = Math.atan((1 - WGS84_F) * Math.tan(phi1));
+  const U2 = Math.atan((1 - WGS84_F) * Math.tan(phi2));
+  const sinU1 = Math.sin(U1);
+  const cosU1 = Math.cos(U1);
+  const sinU2 = Math.sin(U2);
+  const cosU2 = Math.cos(U2);
+  let lambda = L;
+  let prevLambda;
+  let sinSigma = 0;
+  let cosSigma = 0;
+  let sigma = 0;
+  let sinAlpha = 0;
+  let cos2Alpha = 0;
+  let cos2SigmaM = 0;
+  let iterations = MAX_ITERATIONS;
+  do {
+    const sinLambda = Math.sin(lambda);
+    const cosLambda = Math.cos(lambda);
+    const term1 = cosU2 * sinLambda;
+    const term2 = cosU1 * sinU2 - sinU1 * cosU2 * cosLambda;
+    sinSigma = Math.sqrt(term1 * term1 + term2 * term2);
+    if (sinSigma === 0) return 0;
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+    cos2Alpha = 1 - sinAlpha * sinAlpha;
+    cos2SigmaM = cos2Alpha === 0 ? 0 : cosSigma - 2 * sinU1 * sinU2 / cos2Alpha;
+    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);
+  if (iterations === 0) {
+    return haversineDistance(lat1, lon1, lat2, lon2);
+  }
+  const uSq = cos2Alpha * (WGS84_A * WGS84_A - WGS84_B * WGS84_B) / (WGS84_B * WGS84_B);
+  const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  const deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+  return WGS84_B * A * (sigma - deltaSigma);
+}
+
+// src/geo/geo-index.ts
+function createGeoIndex() {
+  const entries = [];
+  return {
+    get entries() {
+      return entries;
+    },
+    insert(docId, lat, lon) {
+      entries.push({ lat, lon, docId });
+    },
+    remove(docId) {
+      for (let i = entries.length - 1; i >= 0; i--) {
+        if (entries[i].docId === docId) {
+          entries.splice(i, 1);
+          return;
+        }
+      }
+    },
+    radiusQuery(lat, lon, distanceMeters, inside, highPrecision) {
+      const result = /* @__PURE__ */ new Set();
+      const distanceFn = highPrecision ? vincentyDistance : haversineDistance;
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const dist = distanceFn(lat, lon, entry.lat, entry.lon);
+        const withinRadius = dist <= distanceMeters;
+        if (inside ? withinRadius : !withinRadius) {
+          result.add(entry.docId);
+        }
+      }
+      return result;
+    },
+    polygonQuery(points, inside) {
+      const result = /* @__PURE__ */ new Set();
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const withinPolygon = isPointInPolygon(entry.lat, entry.lon, points);
+        if (inside ? withinPolygon : !withinPolygon) {
+          result.add(entry.docId);
+        }
+      }
+      return result;
+    },
+    clear() {
+      entries.length = 0;
+    },
+    serialize() {
+      return entries.map((e) => ({ ...e }));
+    },
+    deserialize(data) {
+      entries.length = 0;
+      for (const entry of data) {
+        entries.push({ lat: entry.lat, lon: entry.lon, docId: entry.docId });
+      }
+    }
+  };
+}
+
+// src/vector/similarity.ts
+function magnitude(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    sum += v[i] * v[i];
+  }
+  return Math.sqrt(sum);
+}
+function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
+  if (magA === 0 || magB === 0) return 0;
+  return dotProduct(a, b) / (magA * magB);
+}
+function dotProduct(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function euclideanDistance(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+
+// src/vector/brute-force.ts
+function createBruteForceVectorStore(dimension) {
+  const vectors = /* @__PURE__ */ new Map();
+  return {
+    get dimension() {
+      return dimension;
+    },
+    get size() {
+      return vectors.size;
+    },
+    insert(docId, vector) {
+      if (vector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: expected ${dimension}, got ${vector.length}`);
+      }
+      const mag = magnitude(vector);
+      vectors.set(docId, { docId, vector, magnitude: mag });
+    },
+    remove(docId) {
+      vectors.delete(docId);
+    },
+    has(docId) {
+      return vectors.has(docId);
+    },
+    search(query, k, metric, minSimilarity, filterDocIds) {
+      if (query.length !== dimension) {
+        throw new Error(`Query dimension mismatch: expected ${dimension}, got ${query.length}`);
+      }
+      const queryMag = magnitude(query);
+      const results = [];
+      for (const [docId, entry] of vectors) {
+        if (filterDocIds && !filterDocIds.has(docId)) continue;
+        let score;
+        switch (metric) {
+          case "cosine":
+            score = cosineSimilarityWithMagnitudes(query, entry.vector, queryMag, entry.magnitude);
+            break;
+          case "dotProduct":
+            score = dotProduct(query, entry.vector);
+            break;
+          case "euclidean": {
+            const dist = euclideanDistance(query, entry.vector);
+            score = 1 / (1 + dist);
+            break;
+          }
+        }
+        if (score >= minSimilarity) {
+          results.push({ docId, score });
+        }
+      }
+      results.sort((a, b) => b.score - a.score);
+      const topK = results.slice(0, k);
+      return topK.map((r) => ({
+        docId: r.docId,
+        score: r.score,
+        termFrequencies: {},
+        fieldLengths: {},
+        idf: {}
+      }));
+    },
+    clear() {
+      vectors.clear();
+    },
+    entries() {
+      return vectors.entries();
+    }
+  };
+}
+
+// src/core/field-index.ts
+function lowerBound(entries, value) {
+  let lo = 0;
+  let hi = entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (entries[mid].value < value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function upperBound(entries, value) {
+  let lo = 0;
+  let hi = entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (entries[mid].value <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function collectDocIds(entries, from, to) {
+  const result = /* @__PURE__ */ new Set();
+  for (let i = from; i < to; i++) {
+    result.add(entries[i].docId);
+  }
+  return result;
+}
+function createNumericIndex() {
+  let entries = [];
+  return {
+    insert(docId, value) {
+      const pos = upperBound(entries, value);
+      entries.splice(pos, 0, { value, docId });
+    },
+    remove(docId, value) {
+      const start = lowerBound(entries, value);
+      const end = upperBound(entries, value);
+      for (let i = start; i < end; i++) {
+        if (entries[i].docId === docId) {
+          entries.splice(i, 1);
+          return;
+        }
+      }
+    },
+    queryEq(value) {
+      return collectDocIds(entries, lowerBound(entries, value), upperBound(entries, value));
+    },
+    queryNe(value) {
+      const excluded = this.queryEq(value);
+      const result = /* @__PURE__ */ new Set();
+      for (const entry of entries) {
+        if (!excluded.has(entry.docId)) result.add(entry.docId);
+      }
+      return result;
+    },
+    queryGt(value) {
+      return collectDocIds(entries, upperBound(entries, value), entries.length);
+    },
+    queryGte(value) {
+      return collectDocIds(entries, lowerBound(entries, value), entries.length);
+    },
+    queryLt(value) {
+      return collectDocIds(entries, 0, lowerBound(entries, value));
+    },
+    queryLte(value) {
+      return collectDocIds(entries, 0, upperBound(entries, value));
+    },
+    queryBetween(min, max) {
+      return collectDocIds(entries, lowerBound(entries, min), upperBound(entries, max));
+    },
+    getAllDocIds() {
+      return collectDocIds(entries, 0, entries.length);
+    },
+    count() {
+      return entries.length;
+    },
+    clear() {
+      entries = [];
+    },
+    serialize() {
+      return entries.slice();
+    },
+    deserialize(data) {
+      entries = data.slice();
+    }
+  };
+}
+function createBooleanIndex() {
+  const trueDocs = /* @__PURE__ */ new Set();
+  const falseDocs = /* @__PURE__ */ new Set();
+  return {
+    insert(docId, value) {
+      if (value) trueDocs.add(docId);
+      else falseDocs.add(docId);
+    },
+    remove(docId, value) {
+      if (value) trueDocs.delete(docId);
+      else falseDocs.delete(docId);
+    },
+    queryEq(value) {
+      return new Set(value ? trueDocs : falseDocs);
+    },
+    queryNe(value) {
+      return new Set(value ? falseDocs : trueDocs);
+    },
+    getAllDocIds() {
+      const all = new Set(trueDocs);
+      for (const id of falseDocs) all.add(id);
+      return all;
+    },
+    count() {
+      return trueDocs.size + falseDocs.size;
+    },
+    clear() {
+      trueDocs.clear();
+      falseDocs.clear();
+    },
+    serialize() {
+      return {
+        trueDocs: Array.from(trueDocs),
+        falseDocs: Array.from(falseDocs)
+      };
+    },
+    deserialize(data) {
+      trueDocs.clear();
+      falseDocs.clear();
+      for (const id of data.trueDocs) trueDocs.add(id);
+      for (const id of data.falseDocs) falseDocs.add(id);
+    }
+  };
+}
+function createEnumIndex() {
+  const valueMap = /* @__PURE__ */ new Map();
+  function allDocs() {
+    const result = /* @__PURE__ */ new Set();
+    for (const docSet of valueMap.values()) {
+      for (const id of docSet) result.add(id);
+    }
+    return result;
+  }
+  return {
+    insert(docId, value) {
+      let docSet = valueMap.get(value);
+      if (!docSet) {
+        docSet = /* @__PURE__ */ new Set();
+        valueMap.set(value, docSet);
+      }
+      docSet.add(docId);
+    },
+    remove(docId, value) {
+      const docSet = valueMap.get(value);
+      if (!docSet) return;
+      docSet.delete(docId);
+      if (docSet.size === 0) valueMap.delete(value);
+    },
+    queryEq(value) {
+      const docSet = valueMap.get(value);
+      return docSet ? new Set(docSet) : /* @__PURE__ */ new Set();
+    },
+    queryNe(value) {
+      const excluded = valueMap.get(value);
+      const result = allDocs();
+      if (excluded) {
+        for (const id of excluded) result.delete(id);
+      }
+      return result;
+    },
+    queryIn(values) {
+      const result = /* @__PURE__ */ new Set();
+      for (const val of values) {
+        const docSet = valueMap.get(val);
+        if (docSet) {
+          for (const id of docSet) result.add(id);
+        }
+      }
+      return result;
+    },
+    queryNin(values) {
+      const excluded = this.queryIn(values);
+      const result = allDocs();
+      for (const id of excluded) result.delete(id);
+      return result;
+    },
+    getAllDocIds() {
+      return allDocs();
+    },
+    count() {
+      let total = 0;
+      for (const docSet of valueMap.values()) total += docSet.size;
+      return total;
+    },
+    clear() {
+      valueMap.clear();
+    },
+    serialize() {
+      const result = /* @__PURE__ */ Object.create(null);
+      for (const [value, docSet] of valueMap) {
+        result[value] = Array.from(docSet);
+      }
+      return result;
+    },
+    deserialize(data) {
+      valueMap.clear();
+      for (const value of Object.keys(data)) {
+        valueMap.set(value, new Set(data[value]));
+      }
+    }
+  };
+}
+
+// src/core/partition/utils.ts
+var VECTOR_PATTERN2 = /^vector\[(\d+)]$/;
+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;
+}
+function stringArraysEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function textFieldsChanged(oldDoc, newDoc, flatSchema) {
+  for (const [path, fieldType] of Object.entries(flatSchema)) {
+    if (fieldType !== "string" && fieldType !== "string[]") continue;
+    const oldVal = getNestedValue(oldDoc, path);
+    const newVal = getNestedValue(newDoc, path);
+    if (fieldType === "string") {
+      if (oldVal !== newVal) return true;
+    } else {
+      if (!stringArraysEqual(oldVal, newVal)) return true;
+    }
+  }
+  return false;
+}
+function parseVectorDimension(fieldType) {
+  const match = VECTOR_PATTERN2.exec(fieldType);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+function tokenizeOptions(options) {
+  return {
+    stem: true,
+    removeStopWords: true,
+    stopWordOverride: options?.stopWordOverride,
+    customTokenizer: options?.customTokenizer
+  };
+}
+function getFlatSchema(state, schema) {
+  if (state.lastSchemaRef === schema && state.flatSchemaCache) return state.flatSchemaCache;
+  state.flatSchemaCache = flattenSchema(schema);
+  state.lastSchemaRef = schema;
+  return state.flatSchemaCache;
+}
+function getFieldValueForDoc(docStore, docId, fieldPath) {
+  const stored = docStore.get(docId);
+  if (!stored) return void 0;
+  return getNestedValue(stored.fields, fieldPath);
+}
+function getAllDocIds(docStore) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [id] of docStore.all()) {
+    ids.add(id);
+  }
+  return ids;
+}
+
+// src/core/partition/indexing.ts
+function ensureFieldIndex(state, fieldPath, fieldType) {
+  if ((fieldType === "number" || fieldType === "number[]") && !state.numericIndexes.has(fieldPath)) {
+    state.numericIndexes.set(fieldPath, createNumericIndex());
+  } else if ((fieldType === "boolean" || fieldType === "boolean[]") && !state.booleanIndexes.has(fieldPath)) {
+    state.booleanIndexes.set(fieldPath, createBooleanIndex());
+  } else if ((fieldType === "enum" || fieldType === "enum[]") && !state.enumIndexes.has(fieldPath)) {
+    state.enumIndexes.set(fieldPath, createEnumIndex());
+  } else if (fieldType === "geopoint" && !state.geoIndexes.has(fieldPath)) {
+    state.geoIndexes.set(fieldPath, createGeoIndex());
+  } else {
+    const dim = parseVectorDimension(fieldType);
+    if (dim !== null && !state.vectorStores.has(fieldPath)) {
+      state.vectorStores.set(fieldPath, createBruteForceVectorStore(dim));
+    }
+  }
+}
+function getOrCreateNumericIndex(state, fieldPath) {
+  let idx = state.numericIndexes.get(fieldPath);
+  if (!idx) {
+    idx = createNumericIndex();
+    state.numericIndexes.set(fieldPath, idx);
+  }
+  return idx;
+}
+function getOrCreateBooleanIndex(state, fieldPath) {
+  let idx = state.booleanIndexes.get(fieldPath);
+  if (!idx) {
+    idx = createBooleanIndex();
+    state.booleanIndexes.set(fieldPath, idx);
+  }
+  return idx;
+}
+function indexStringField(state, docId, fieldPath, text, language, options, fieldLengths, tokensByField) {
+  const result = tokenize(text, language, tokenizeOptions(options));
+  fieldLengths[fieldPath] = result.tokens.length;
+  const fieldTokenList = [];
+  const tokenFreqs = /* @__PURE__ */ new Map();
+  for (const t of result.tokens) {
+    const existing = tokenFreqs.get(t.token);
+    if (existing) {
+      existing.count++;
+      existing.positions.push(t.position);
+    } else {
+      tokenFreqs.set(t.token, { count: 1, positions: [t.position] });
+    }
+    fieldTokenList.push(t.token);
+  }
+  for (const [token, freq] of tokenFreqs) {
+    state.invertedIdx.insert(token, {
+      docId,
+      termFrequency: freq.count,
+      fieldName: fieldPath,
+      positions: freq.positions
+    });
+  }
+  tokensByField[fieldPath] = fieldTokenList;
+}
+function indexStringArrayField(state, docId, fieldPath, arr, language, options, fieldLengths, tokensByField) {
+  const tokenFreqs = /* @__PURE__ */ new Map();
+  const fieldTokenList = [];
+  let positionOffset = 0;
+  for (const item of arr) {
+    const result = tokenize(item, language, tokenizeOptions(options));
+    for (const t of result.tokens) {
+      const existing = tokenFreqs.get(t.token);
+      if (existing) {
+        existing.count++;
+        existing.positions.push(positionOffset + t.position);
+      } else {
+        tokenFreqs.set(t.token, { count: 1, positions: [positionOffset + t.position] });
+      }
+      fieldTokenList.push(t.token);
+    }
+    positionOffset += result.tokens.length;
+  }
+  fieldLengths[fieldPath] = fieldTokenList.length;
+  for (const [token, freq] of tokenFreqs) {
+    state.invertedIdx.insert(token, {
+      docId,
+      termFrequency: freq.count,
+      fieldName: fieldPath,
+      positions: freq.positions
+    });
+  }
+  tokensByField[fieldPath] = fieldTokenList;
+}
+function indexDocument(state, docId, document, flatSchema, language, options) {
+  const fieldLengths = {};
+  const tokensByField = {};
+  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
+    const value = getNestedValue(document, fieldPath);
+    if (value === void 0 || value === null) continue;
+    ensureFieldIndex(state, fieldPath, fieldType);
+    if (fieldType === "string") {
+      indexStringField(state, docId, fieldPath, value, language, options, fieldLengths, tokensByField);
+    } else if (fieldType === "number") {
+      getOrCreateNumericIndex(state, fieldPath).insert(docId, value);
+    } else if (fieldType === "boolean") {
+      getOrCreateBooleanIndex(state, fieldPath).insert(docId, value);
+    } else if (fieldType === "enum") {
+      state.enumIndexes.get(fieldPath)?.insert(docId, value);
+    } else if (fieldType === "geopoint") {
+      const geo = value;
+      state.geoIndexes.get(fieldPath)?.insert(docId, geo.lat, geo.lon);
+    } else if (fieldType === "string[]") {
+      indexStringArrayField(state, docId, fieldPath, value, language, options, fieldLengths, tokensByField);
+    } else if (fieldType === "number[]") {
+      const numIdx = getOrCreateNumericIndex(state, fieldPath);
+      for (const num of value) numIdx.insert(docId, num);
+    } else if (fieldType === "boolean[]") {
+      const boolIdx = getOrCreateBooleanIndex(state, fieldPath);
+      for (const b of value) boolIdx.insert(docId, b);
+    } else if (fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        for (const e of value) enumIdx.insert(docId, e);
+      }
+    } else {
+      const dim = parseVectorDimension(fieldType);
+      if (dim !== null) {
+        const vec = value instanceof Float32Array ? value : new Float32Array(value);
+        state.vectorStores.get(fieldPath)?.insert(docId, vec);
+      }
+    }
+  }
+  return { fieldLengths, tokensByField };
+}
+function removeFromIndexes(state, docId, storedDoc, flatSchema, language, options) {
+  const fieldLengths = {};
+  const tokensByField = {};
+  const fields = storedDoc.fields;
+  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
+    const value = getNestedValue(fields, fieldPath);
+    if (value === void 0 || value === null) continue;
+    if (fieldType === "string") {
+      const result = tokenize(value, language, tokenizeOptions(options));
+      fieldLengths[fieldPath] = result.tokens.length;
+      const uniqueTokens = /* @__PURE__ */ new Set();
+      const fieldTokenList = [];
+      for (const t of result.tokens) {
+        uniqueTokens.add(t.token);
+        fieldTokenList.push(t.token);
+      }
+      for (const token of uniqueTokens) state.invertedIdx.remove(token, docId);
+      tokensByField[fieldPath] = fieldTokenList;
+    } else if (fieldType === "number") {
+      state.numericIndexes.get(fieldPath)?.remove(docId, value);
+    } else if (fieldType === "boolean") {
+      state.booleanIndexes.get(fieldPath)?.remove(docId, value);
+    } else if (fieldType === "enum") {
+      state.enumIndexes.get(fieldPath)?.remove(docId, value);
+    } else if (fieldType === "geopoint") {
+      state.geoIndexes.get(fieldPath)?.remove(docId);
+    } else if (fieldType === "string[]") {
+      const arr = value;
+      const uniqueTokens = /* @__PURE__ */ new Set();
+      const fieldTokenList = [];
+      for (const item of arr) {
+        const result = tokenize(item, language, tokenizeOptions(options));
+        for (const t of result.tokens) {
+          uniqueTokens.add(t.token);
+          fieldTokenList.push(t.token);
+        }
+      }
+      fieldLengths[fieldPath] = fieldTokenList.length;
+      for (const token of uniqueTokens) state.invertedIdx.remove(token, docId);
+      tokensByField[fieldPath] = fieldTokenList;
+    } else if (fieldType === "number[]") {
+      const numIdx = state.numericIndexes.get(fieldPath);
+      if (numIdx) {
+        for (const num of value) numIdx.remove(docId, num);
+      }
+    } else if (fieldType === "boolean[]") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        for (const b of value) boolIdx.remove(docId, b);
+      }
+    } else if (fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        for (const e of value) enumIdx.remove(docId, e);
+      }
+    } else {
+      if (parseVectorDimension(fieldType) !== null) {
+        state.vectorStores.get(fieldPath)?.remove(docId);
+      }
+    }
+  }
+  return { fieldLengths, tokensByField };
+}
+function updateFieldIndexOnly(state, docId, oldFields, newDoc, flatSchema) {
+  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
+    if (fieldType === "string" || fieldType === "string[]") continue;
+    const oldVal = getNestedValue(oldFields, fieldPath);
+    const newVal = getNestedValue(newDoc, fieldPath);
+    if (oldVal === newVal) continue;
+    if (oldVal !== void 0 && oldVal !== null && newVal !== void 0 && newVal !== null && typeof oldVal === typeof newVal && JSON.stringify(oldVal) === JSON.stringify(newVal))
+      continue;
+    if (newVal !== void 0 && newVal !== null) {
+      ensureFieldIndex(state, fieldPath, fieldType);
+    }
+    if (fieldType === "number") {
+      const numIdx = state.numericIndexes.get(fieldPath);
+      if (numIdx) {
+        if (oldVal !== void 0 && oldVal !== null) numIdx.remove(docId, oldVal);
+        if (newVal !== void 0 && newVal !== null) numIdx.insert(docId, newVal);
+      }
+    } else if (fieldType === "boolean") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        if (oldVal !== void 0 && oldVal !== null) boolIdx.remove(docId, oldVal);
+        if (newVal !== void 0 && newVal !== null) boolIdx.insert(docId, newVal);
+      }
+    } else if (fieldType === "enum") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        if (oldVal !== void 0 && oldVal !== null) enumIdx.remove(docId, oldVal);
+        if (newVal !== void 0 && newVal !== null) enumIdx.insert(docId, newVal);
+      }
+    } else if (fieldType === "geopoint") {
+      const geoIdx = state.geoIndexes.get(fieldPath);
+      if (geoIdx) {
+        if (oldVal !== void 0 && oldVal !== null) geoIdx.remove(docId);
+        if (newVal !== void 0 && newVal !== null) {
+          const geo = newVal;
+          geoIdx.insert(docId, geo.lat, geo.lon);
+        }
+      }
+    } else if (fieldType === "number[]") {
+      const numIdx = state.numericIndexes.get(fieldPath);
+      if (numIdx) {
+        if (oldVal !== void 0 && oldVal !== null) {
+          for (const n of oldVal) numIdx.remove(docId, n);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const n of newVal) numIdx.insert(docId, n);
+        }
+      }
+    } else if (fieldType === "boolean[]") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        if (oldVal !== void 0 && oldVal !== null) {
+          for (const b of oldVal) boolIdx.remove(docId, b);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const b of newVal) boolIdx.insert(docId, b);
+        }
+      }
+    } else if (fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        if (oldVal !== void 0 && oldVal !== null) {
+          for (const e of oldVal) enumIdx.remove(docId, e);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const e of newVal) enumIdx.insert(docId, e);
+        }
+      }
+    } else if (parseVectorDimension(fieldType) !== null) {
+      const vecStore = state.vectorStores.get(fieldPath);
+      if (vecStore) {
+        vecStore.remove(docId);
+        if (newVal !== void 0 && newVal !== null) {
+          const vec = newVal instanceof Float32Array ? newVal : new Float32Array(newVal);
+          vecStore.insert(docId, vec);
+        }
+      }
+    }
+  }
+}
+
+// src/filters/combinators.ts
+function applyAnd(sets) {
+  if (sets.length === 0) return /* @__PURE__ */ new Set();
+  if (sets.length === 1) return sets[0];
+  const sorted = [...sets].sort((a, b) => a.size - b.size);
+  let result = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i];
+    const intersection = /* @__PURE__ */ new Set();
+    for (const item of result) {
+      if (next.has(item)) intersection.add(item);
+    }
+    result = intersection;
+    if (result.size === 0) break;
+  }
+  return result;
+}
+function applyOr(sets) {
+  if (sets.length === 0) return /* @__PURE__ */ new Set();
+  if (sets.length === 1) return sets[0];
+  const result = /* @__PURE__ */ new Set();
+  for (const set of sets) {
+    for (const item of set) {
+      result.add(item);
+    }
+  }
+  return result;
+}
+function applyNot(universe, excluded) {
+  const result = /* @__PURE__ */ new Set();
+  for (const item of universe) {
+    if (!excluded.has(item)) result.add(item);
+  }
+  return result;
+}
+
+// src/filters/operators.ts
+var METERS_PER_KM = 1e3;
+var METERS_PER_MI = 1609.344;
+function convertToMeters(distance, unit) {
+  if (unit === "km") return distance * METERS_PER_KM;
+  if (unit === "mi") return distance * METERS_PER_MI;
+  return distance;
+}
+function setDifference(a, b) {
+  const result = /* @__PURE__ */ new Set();
+  for (const item of a) {
+    if (!b.has(item)) result.add(item);
+  }
+  return result;
+}
+function applyEq(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric" && typeof value === "number") {
+    return fieldIndex.index.eq(value);
+  }
+  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
+    return value ? fieldIndex.index.getTrue() : fieldIndex.index.getFalse();
+  }
+  if (fieldIndex?.type === "enum" && typeof value === "string") {
+    return fieldIndex.index.getDocIds(value);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    if (getValue(docId) === value) result.add(docId);
+  }
+  return result;
+}
+function applyNe(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric" && typeof value === "number") {
+    return setDifference(fieldIndex.index.allDocIds(), fieldIndex.index.eq(value));
+  }
+  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
+    return value ? fieldIndex.index.getFalse() : fieldIndex.index.getTrue();
+  }
+  if (fieldIndex?.type === "enum" && typeof value === "string") {
+    return setDifference(fieldIndex.index.allDocIds(), fieldIndex.index.getDocIds(value));
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v !== void 0 && v !== null && v !== value) result.add(docId);
+  }
+  return result;
+}
+function applyGt(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.gt(value);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "number" && v > value) result.add(docId);
+  }
+  return result;
+}
+function applyLt(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.lt(value);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "number" && v < value) result.add(docId);
+  }
+  return result;
+}
+function applyGte(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.gte(value);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "number" && v >= value) result.add(docId);
+  }
+  return result;
+}
+function applyLte(value, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.lte(value);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "number" && v <= value) result.add(docId);
+  }
+  return result;
+}
+function applyBetween(range, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.between(range[0], range[1]);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "number" && v >= range[0] && v <= range[1]) result.add(docId);
+  }
+  return result;
+}
+function applyIn(values, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "enum") {
+    const result2 = /* @__PURE__ */ new Set();
+    for (const val of values) {
+      for (const docId of fieldIndex.index.getDocIds(val)) {
+        result2.add(docId);
+      }
+    }
+    return result2;
+  }
+  const valSet = new Set(values);
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "string" && valSet.has(v)) result.add(docId);
+  }
+  return result;
+}
+function applyNin(values, docIds, getValue, fieldIndex) {
+  if (fieldIndex?.type === "enum") {
+    const matched = /* @__PURE__ */ new Set();
+    for (const val of values) {
+      for (const docId of fieldIndex.index.getDocIds(val)) {
+        matched.add(docId);
+      }
+    }
+    return setDifference(fieldIndex.index.allDocIds(), matched);
+  }
+  const valSet = new Set(values);
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v !== void 0 && v !== null && typeof v === "string" && !valSet.has(v)) result.add(docId);
+  }
+  return result;
+}
+function applyStartsWith(prefix, docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "string" && v.startsWith(prefix)) result.add(docId);
+  }
+  return result;
+}
+function applyEndsWith(suffix, docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (typeof v === "string" && v.endsWith(suffix)) result.add(docId);
+  }
+  return result;
+}
+function applyContainsAll(values, docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (!Array.isArray(v)) continue;
+    const arr = v;
+    let allFound = true;
+    for (const val of values) {
+      if (!arr.includes(val)) {
+        allFound = false;
+        break;
+      }
+    }
+    if (allFound) result.add(docId);
+  }
+  return result;
+}
+function applyMatchesAny(values, docIds, getValue) {
+  const valSet = new Set(values);
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (!Array.isArray(v)) continue;
+    for (const item of v) {
+      if (valSet.has(item)) {
+        result.add(docId);
+        break;
+      }
+    }
+  }
+  return result;
+}
+function applySize(sizeFilter, docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (!Array.isArray(v)) continue;
+    if (matchesNumericComparison(v.length, sizeFilter)) result.add(docId);
+  }
+  return result;
+}
+function applyExists(docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v !== void 0 && v !== null) result.add(docId);
+  }
+  return result;
+}
+function applyNotExists(docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v === void 0 || v === null) result.add(docId);
+  }
+  return result;
+}
+function applyIsEmpty(docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v === void 0 || v === null) {
+      result.add(docId);
+      continue;
+    }
+    if (typeof v === "string" && v === "") {
+      result.add(docId);
+      continue;
+    }
+    if (Array.isArray(v) && v.length === 0) {
+      result.add(docId);
+    }
+  }
+  return result;
+}
+function applyIsNotEmpty(docIds, getValue) {
+  const result = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    const v = getValue(docId);
+    if (v === void 0 || v === null) continue;
+    if (typeof v === "string" && v === "") continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    result.add(docId);
+  }
+  return result;
+}
+function applyGeoRadius(filter, geoIndex) {
+  const distanceMeters = convertToMeters(filter.distance, filter.unit);
+  return geoIndex.radiusQuery(
+    filter.lat,
+    filter.lon,
+    distanceMeters,
+    filter.inside ?? true,
+    filter.highPrecision ?? false
+  );
+}
+function applyGeoPolygon(filter, geoIndex) {
+  return geoIndex.polygonQuery(filter.points, filter.inside ?? true);
+}
+function matchesNumericComparison(value, filter) {
+  if (filter.eq !== void 0 && value !== filter.eq) return false;
+  if (filter.ne !== void 0 && value === filter.ne) return false;
+  if (filter.gt !== void 0 && !(value > filter.gt)) return false;
+  if (filter.lt !== void 0 && !(value < filter.lt)) return false;
+  if (filter.gte !== void 0 && !(value >= filter.gte)) return false;
+  if (filter.lte !== void 0 && !(value <= filter.lte)) return false;
+  if (filter.between !== void 0 && !(value >= filter.between[0] && value <= filter.between[1])) return false;
+  return true;
+}
+
+// src/filters/evaluator.ts
+function evaluateFilters(expression, context) {
+  const sets = [];
+  if (expression.fields) {
+    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
+      sets.push(evaluateFieldFilter(fieldPath, filter, context));
+    }
+  }
+  if (expression.and?.length) {
+    const andSets = expression.and.map((expr) => evaluateFilters(expr, context));
+    sets.push(applyAnd(andSets));
+  }
+  if (expression.or?.length) {
+    const orSets = expression.or.map((expr) => evaluateFilters(expr, context));
+    sets.push(applyOr(orSets));
+  }
+  if (expression.not) {
+    const excluded = evaluateFilters(expression.not, context);
+    sets.push(applyNot(context.allDocIds, excluded));
+  }
+  if (sets.length === 0) return new Set(context.allDocIds);
+  if (sets.length === 1) return sets[0];
+  return applyAnd(sets);
+}
+function evaluateFieldFilter(fieldPath, filter, context) {
+  const fieldIndex = context.fieldIndexes[fieldPath];
+  const getValue = (docId) => context.getFieldValue(docId, fieldPath);
+  const f = filter;
+  const sets = [];
+  if ("radius" in f && f.radius) {
+    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
+    sets.push(applyGeoRadius(filter.radius, geoIndex));
+  }
+  if ("polygon" in f && f.polygon) {
+    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
+    sets.push(applyGeoPolygon(filter.polygon, geoIndex));
+  }
+  if ("eq" in f && f.eq !== void 0) {
+    sets.push(applyEq(f.eq, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("ne" in f && f.ne !== void 0) {
+    sets.push(applyNe(f.ne, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("gt" in f && f.gt !== void 0) {
+    sets.push(applyGt(f.gt, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("lt" in f && f.lt !== void 0) {
+    sets.push(applyLt(f.lt, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("gte" in f && f.gte !== void 0) {
+    sets.push(applyGte(f.gte, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("lte" in f && f.lte !== void 0) {
+    sets.push(applyLte(f.lte, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("between" in f && f.between !== void 0) {
+    sets.push(applyBetween(f.between, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("in" in f && f.in !== void 0) {
+    sets.push(applyIn(f.in, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("nin" in f && f.nin !== void 0) {
+    sets.push(applyNin(f.nin, context.allDocIds, getValue, fieldIndex));
+  }
+  if ("startsWith" in f && f.startsWith !== void 0) {
+    sets.push(applyStartsWith(f.startsWith, context.allDocIds, getValue));
+  }
+  if ("endsWith" in f && f.endsWith !== void 0) {
+    sets.push(applyEndsWith(f.endsWith, context.allDocIds, getValue));
+  }
+  if ("containsAll" in f && f.containsAll !== void 0) {
+    sets.push(applyContainsAll(f.containsAll, context.allDocIds, getValue));
+  }
+  if ("matchesAny" in f && f.matchesAny !== void 0) {
+    sets.push(applyMatchesAny(f.matchesAny, context.allDocIds, getValue));
+  }
+  if ("size" in f && f.size !== void 0) {
+    sets.push(applySize(f.size, context.allDocIds, getValue));
+  }
+  if ("exists" in f && f.exists !== void 0) {
+    sets.push(f.exists ? applyExists(context.allDocIds, getValue) : applyNotExists(context.allDocIds, getValue));
+  }
+  if ("notExists" in f && f.notExists !== void 0) {
+    sets.push(f.notExists ? applyNotExists(context.allDocIds, getValue) : applyExists(context.allDocIds, getValue));
+  }
+  if ("isEmpty" in f && f.isEmpty !== void 0) {
+    sets.push(f.isEmpty ? applyIsEmpty(context.allDocIds, getValue) : applyIsNotEmpty(context.allDocIds, getValue));
+  }
+  if ("isNotEmpty" in f && f.isNotEmpty !== void 0) {
+    sets.push(f.isNotEmpty ? applyIsNotEmpty(context.allDocIds, getValue) : applyIsEmpty(context.allDocIds, getValue));
+  }
+  if (sets.length === 0) return new Set(context.allDocIds);
+  if (sets.length === 1) return sets[0];
+  return applyAnd(sets);
+}
+function resolveGeoIndex(fieldPath, fieldIndex) {
+  if (fieldIndex?.type !== "geopoint") {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_FILTER,
+      `Field "${fieldPath}" requires a geopoint index for geo filters`,
+      { fieldPath }
+    );
+  }
+  return fieldIndex.index;
+}
+
+// src/core/scorer.ts
+var DEFAULT_K1 = 1.2;
+var DEFAULT_B = 0.75;
+function computeIDF(docFrequency, totalDocs) {
+  if (totalDocs === 0) return 0;
+  return Math.log((totalDocs - docFrequency + 0.5) / (docFrequency + 0.5) + 1);
+}
+function computeBM25(termFrequency, docFrequency, totalDocs, fieldLength, avgFieldLength, params) {
+  if (totalDocs === 0) return 0;
+  if (avgFieldLength === 0) return 0;
+  const k1 = params?.k1 ?? DEFAULT_K1;
+  const b = params?.b ?? DEFAULT_B;
+  const idf = computeIDF(docFrequency, totalDocs);
+  const numerator = termFrequency * (k1 + 1);
+  const denominator = termFrequency + k1 * (1 - b + b * fieldLength / avgFieldLength);
+  if (denominator === 0) return 0;
+  return idf * (numerator / denominator);
+}
+function computeBM25WithGlobalStats(termFrequency, globalDocFrequency, globalTotalDocs, fieldLength, globalAvgFieldLength, params) {
+  return computeBM25(termFrequency, globalDocFrequency, globalTotalDocs, fieldLength, globalAvgFieldLength, params);
+}
+
+// src/core/partition/search.ts
+function searchFulltext(state, params) {
+  const { queryTokens, fields, boost, tolerance = 0, prefixLength = 2, exact = false, bm25Params, globalStats } = params;
+  if (queryTokens.length === 0) {
+    return { scored: [], totalMatched: 0 };
+  }
+  const docScores = /* @__PURE__ */ new Map();
+  const totalDocs = globalStats?.totalDocuments ?? state.stats.totalDocuments;
+  const avgFieldLengths = globalStats?.averageFieldLengths ?? state.stats.averageFieldLengths;
+  const globalDocFreqs = globalStats?.docFrequencies ?? state.stats.docFrequencies;
+  for (const qt of queryTokens) {
+    const matchingPostings = exact ? (() => {
+      const postingList = state.invertedIdx.lookup(qt.token);
+      return postingList ? [{ token: qt.token, postingList }] : [];
+    })() : state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength);
+    for (const match of matchingPostings) {
+      const docFreq = globalStats ? globalDocFreqs[match.token] ?? match.postingList.docFrequency : match.postingList.docFrequency;
+      const idf = computeIDF(docFreq, totalDocs);
+      for (const posting of match.postingList.postings) {
+        if (fields && !fields.includes(posting.fieldName)) continue;
+        const fieldBoost = boost?.[posting.fieldName] ?? 1;
+        const avgLen = avgFieldLengths[posting.fieldName] ?? 1;
+        const storedDoc = state.docStore.get(posting.docId);
+        const actualFieldLength = storedDoc?.fieldLengths[posting.fieldName] ?? avgLen;
+        const scoreFn = globalStats ? computeBM25WithGlobalStats : computeBM25;
+        let termScore = scoreFn(posting.termFrequency, docFreq, totalDocs, actualFieldLength, avgLen, bm25Params);
+        termScore *= fieldBoost;
+        const existing = docScores.get(posting.docId);
+        if (existing) {
+          existing.score += termScore;
+          existing.termFrequencies[`${posting.fieldName}:${match.token}`] = posting.termFrequency;
+          existing.fieldLengths[posting.fieldName] = actualFieldLength;
+          existing.idf[match.token] = idf;
+          existing.matchedTermCount++;
+        } else {
+          docScores.set(posting.docId, {
+            score: termScore,
+            termFrequencies: { [`${posting.fieldName}:${match.token}`]: posting.termFrequency },
+            fieldLengths: { [posting.fieldName]: actualFieldLength },
+            idf: { [match.token]: idf },
+            matchedTermCount: 1
+          });
+        }
+      }
+    }
+  }
+  const scored = [];
+  for (const [docId, data] of docScores) {
+    scored.push({
+      docId,
+      score: data.score,
+      termFrequencies: data.termFrequencies,
+      fieldLengths: data.fieldLengths,
+      idf: data.idf
+    });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return { scored, totalMatched: scored.length };
+}
+function searchVector(state, params) {
+  const { field, value, k, similarity = 0, metric = "cosine", filterDocIds } = params;
+  const vecStore = state.vectorStores.get(field);
+  if (!vecStore) {
+    return { scored: [], totalMatched: 0 };
+  }
+  if (value.length !== vecStore.dimension) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_VECTOR_SIZE,
+      `Query vector dimension ${value.length} does not match field "${field}" dimension ${vecStore.dimension}`,
+      { field, expected: vecStore.dimension, received: value.length }
+    );
+  }
+  const queryVec = new Float32Array(value);
+  const results = vecStore.search(queryVec, k, metric, similarity, filterDocIds);
+  return { scored: results, totalMatched: results.length };
+}
+function buildFilterContext(state, schema) {
+  const flat = getFlatSchema(state, schema);
+  const fieldIndexes = {};
+  for (const [fieldPath, fieldType] of Object.entries(flat)) {
+    if (fieldType === "number" || fieldType === "number[]") {
+      const numIdx = state.numericIndexes.get(fieldPath);
+      if (numIdx) {
+        fieldIndexes[fieldPath] = {
+          type: "numeric",
+          index: {
+            eq: (v) => numIdx.queryEq(v),
+            gt: (v) => numIdx.queryGt(v),
+            gte: (v) => numIdx.queryGte(v),
+            lt: (v) => numIdx.queryLt(v),
+            lte: (v) => numIdx.queryLte(v),
+            between: (min, max) => numIdx.queryBetween(min, max),
+            allDocIds: () => numIdx.getAllDocIds()
+          }
+        };
+      }
+    } else if (fieldType === "boolean" || fieldType === "boolean[]") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        fieldIndexes[fieldPath] = {
+          type: "boolean",
+          index: {
+            getTrue: () => boolIdx.queryEq(true),
+            getFalse: () => boolIdx.queryEq(false),
+            allDocIds: () => boolIdx.getAllDocIds()
+          }
+        };
+      }
+    } else if (fieldType === "enum" || fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        fieldIndexes[fieldPath] = {
+          type: "enum",
+          index: {
+            getDocIds: (v) => enumIdx.queryEq(v),
+            allDocIds: () => enumIdx.getAllDocIds()
+          }
+        };
+      }
+    } else if (fieldType === "geopoint") {
+      const geoIdx = state.geoIndexes.get(fieldPath);
+      if (geoIdx) {
+        fieldIndexes[fieldPath] = {
+          type: "geopoint",
+          index: geoIdx
+        };
+      }
+    }
+  }
+  let cachedAllDocIds = null;
+  return {
+    fieldIndexes,
+    getFieldValue: (docId, fieldPath) => getFieldValueForDoc(state.docStore, docId, fieldPath),
+    get allDocIds() {
+      if (!cachedAllDocIds) {
+        cachedAllDocIds = getAllDocIds(state.docStore);
+      }
+      return cachedAllDocIds;
+    }
+  };
+}
+function applyPartitionFilters(state, filters, schema) {
+  const context = buildFilterContext(state, schema);
+  return evaluateFilters(filters, context);
+}
+function computeFacets(state, docIds, config, schema) {
+  const result = {};
+  const flatSchema = getFlatSchema(state, schema);
+  for (const [fieldPath, facetOpts] of Object.entries(config)) {
+    const fieldType = flatSchema[fieldPath];
+    if (!fieldType) continue;
+    const valueCounts = /* @__PURE__ */ new Map();
+    if (facetOpts.ranges && (fieldType === "number" || fieldType === "number[]")) {
+      for (const range of facetOpts.ranges) {
+        const label = `${range.from}-${range.to}`;
+        let count = 0;
+        for (const docId of docIds) {
+          const val = getFieldValueForDoc(state.docStore, docId, fieldPath);
+          if (fieldType === "number[]" && Array.isArray(val)) {
+            for (const v of val) {
+              if (v >= range.from && v < range.to) {
+                count++;
+                break;
+              }
+            }
+          } else if (typeof val === "number" && val >= range.from && val < range.to) {
+            count++;
+          }
+        }
+        valueCounts.set(label, count);
+      }
+    } else {
+      for (const docId of docIds) {
+        const val = getFieldValueForDoc(state.docStore, docId, fieldPath);
+        if (val === void 0 || val === null) continue;
+        if (Array.isArray(val)) {
+          for (const item of val) {
+            const key = String(item);
+            valueCounts.set(key, (valueCounts.get(key) ?? 0) + 1);
+          }
+        } else {
+          const key = String(val);
+          valueCounts.set(key, (valueCounts.get(key) ?? 0) + 1);
+        }
+      }
+    }
+    let entries = Array.from(valueCounts.entries());
+    const sortDir = facetOpts.sort ?? "desc";
+    entries.sort((a, b) => sortDir === "asc" ? a[1] - b[1] : b[1] - a[1]);
+    if (facetOpts.limit && facetOpts.limit > 0) {
+      entries = entries.slice(0, facetOpts.limit);
+    }
+    const values = {};
+    for (const [key, count] of entries) {
+      values[key] = count;
+    }
+    result[fieldPath] = { values, count: entries.length };
+  }
+  return result;
+}
+
+// src/core/partition/serialization.ts
+function serializePartition(state, partitionId, indexName, totalPartitions, language, schema) {
+  const flatSchema = getFlatSchema(state, schema);
+  const flatSchemaStrings = {};
+  for (const [k, v] of Object.entries(flatSchema)) {
+    flatSchemaStrings[k] = v;
+  }
+  const serializedDocs = /* @__PURE__ */ Object.create(null);
+  for (const [docId, stored] of state.docStore.all()) {
+    serializedDocs[docId] = {
+      fields: structuredClone(stored.fields),
+      fieldLengths: { ...stored.fieldLengths }
+    };
+  }
+  const serializedInverted = state.invertedIdx.serialize();
+  const serializedInvertedIndex = /* @__PURE__ */ Object.create(null);
+  for (const [token, list] of Object.entries(serializedInverted)) {
+    serializedInvertedIndex[token] = {
+      docFrequency: list.docFrequency,
+      postings: list.postings.map((p) => ({
+        docId: p.docId,
+        termFrequency: p.termFrequency,
+        field: p.fieldName,
+        positions: [...p.positions]
+      }))
+    };
+  }
+  const serializedNumeric = {};
+  for (const [path, idx] of state.numericIndexes) {
+    serializedNumeric[path] = idx.serialize();
+  }
+  const serializedBoolean = {};
+  for (const [path, idx] of state.booleanIndexes) {
+    serializedBoolean[path] = idx.serialize();
+  }
+  const serializedEnum = {};
+  for (const [path, idx] of state.enumIndexes) {
+    serializedEnum[path] = idx.serialize();
+  }
+  const serializedGeo = {};
+  for (const [path, idx] of state.geoIndexes) {
+    serializedGeo[path] = idx.serialize();
+  }
+  const serializedVectors = {};
+  for (const [path, store] of state.vectorStores) {
+    const vectors = [];
+    for (const [, entry] of store.entries()) {
+      vectors.push({
+        docId: entry.docId,
+        vector: Array.from(entry.vector)
+      });
+    }
+    serializedVectors[path] = {
+      dimension: store.dimension,
+      vectors,
+      hnswGraph: null
+    };
+  }
+  const serializedStats = state.stats.serialize();
+  return {
+    indexName,
+    partitionId,
+    totalPartitions,
+    language,
+    schema: flatSchemaStrings,
+    docCount: state.docStore.count(),
+    avgDocLength: Object.values(serializedStats.averageFieldLengths).reduce((sum, v) => sum + v, 0),
+    documents: serializedDocs,
+    invertedIndex: serializedInvertedIndex,
+    fieldIndexes: {
+      numeric: serializedNumeric,
+      boolean: serializedBoolean,
+      enum: serializedEnum,
+      geopoint: serializedGeo
+    },
+    vectorData: serializedVectors,
+    statistics: serializedStats
+  };
+}
+function deserializePartition(state, data, clearFn, schema) {
+  clearFn();
+  const invertedData = /* @__PURE__ */ Object.create(null);
+  for (const [token, list] of Object.entries(data.invertedIndex)) {
+    invertedData[token] = {
+      docFrequency: list.docFrequency,
+      postings: list.postings.map((p) => ({
+        docId: p.docId,
+        termFrequency: p.termFrequency,
+        fieldName: p.field,
+        positions: [...p.positions]
+      }))
+    };
+  }
+  state.invertedIdx.deserialize(invertedData);
+  const docsData = /* @__PURE__ */ Object.create(null);
+  for (const [docId, doc] of Object.entries(data.documents)) {
+    docsData[docId] = { fields: doc.fields, fieldLengths: doc.fieldLengths };
+  }
+  state.docStore.deserialize(docsData);
+  for (const [path, entries] of Object.entries(data.fieldIndexes.numeric)) {
+    const idx = createNumericIndex();
+    idx.deserialize(entries);
+    state.numericIndexes.set(path, idx);
+  }
+  for (const [path, serialized] of Object.entries(data.fieldIndexes.boolean)) {
+    const idx = createBooleanIndex();
+    idx.deserialize(serialized);
+    state.booleanIndexes.set(path, idx);
+  }
+  for (const [path, serialized] of Object.entries(data.fieldIndexes.enum)) {
+    const idx = createEnumIndex();
+    idx.deserialize(serialized);
+    state.enumIndexes.set(path, idx);
+  }
+  for (const [path, entries] of Object.entries(data.fieldIndexes.geopoint)) {
+    const geoIdx = createGeoIndex();
+    geoIdx.deserialize(entries);
+    state.geoIndexes.set(path, geoIdx);
+  }
+  for (const [path, vecData] of Object.entries(data.vectorData)) {
+    const store = createBruteForceVectorStore(vecData.dimension);
+    for (const entry of vecData.vectors) {
+      store.insert(entry.docId, new Float32Array(entry.vector));
+    }
+    state.vectorStores.set(path, store);
+  }
+  state.stats.deserialize(data.statistics);
+  const flatSchema = getFlatSchema(state, schema);
+  const serializedFields = data.schema;
+  for (const [field, expectedType] of Object.entries(flatSchema)) {
+    if (field in serializedFields && serializedFields[field] !== expectedType) {
+      throw new Error(
+        `Schema mismatch on field "${field}": expected "${expectedType}", found "${serializedFields[field]}"`
+      );
+    }
+  }
+  for (const field of Object.keys(serializedFields)) {
+    if (!(field in flatSchema)) {
+      throw new Error(`Schema mismatch: serialized data contains unknown field "${field}" not present in schema`);
+    }
+  }
+}
+
+// src/core/partition/index.ts
+function createPartitionIndex(partitionId) {
+  const state = {
+    invertedIdx: createInvertedIndex(),
+    docStore: createDocumentStore(),
+    stats: createPartitionStats(),
+    numericIndexes: /* @__PURE__ */ new Map(),
+    booleanIndexes: /* @__PURE__ */ new Map(),
+    enumIndexes: /* @__PURE__ */ new Map(),
+    geoIndexes: /* @__PURE__ */ new Map(),
+    vectorStores: /* @__PURE__ */ new Map(),
+    flatSchemaCache: null,
+    lastSchemaRef: null
+  };
+  function clearAll() {
+    state.invertedIdx.clear();
+    state.docStore.clear();
+    for (const idx of state.numericIndexes.values()) idx.clear();
+    for (const idx of state.booleanIndexes.values()) idx.clear();
+    for (const idx of state.enumIndexes.values()) idx.clear();
+    for (const idx of state.geoIndexes.values()) idx.clear();
+    for (const store of state.vectorStores.values()) store.clear();
+    state.numericIndexes.clear();
+    state.booleanIndexes.clear();
+    state.enumIndexes.clear();
+    state.geoIndexes.clear();
+    state.vectorStores.clear();
+    state.stats.deserialize({ totalDocuments: 0, totalFieldLengths: {}, averageFieldLengths: {}, docFrequencies: {} });
+    state.flatSchemaCache = null;
+    state.lastSchemaRef = null;
+  }
+  const partition = {
+    get partitionId() {
+      return partitionId;
+    },
+    get stats() {
+      return state.stats;
+    },
+    insert(docId, document, schema, language, options) {
+      if (state.docStore.has(docId)) {
+        throw new NarsilError(
+          ErrorCodes.DOC_ALREADY_EXISTS,
+          `Document "${docId}" already exists in partition ${partitionId}`,
+          { docId, partitionId }
+        );
+      }
+      if (options?.validate !== false) {
+        validateDocument(document, schema);
+      }
+      const flatSchema = getFlatSchema(state, schema);
+      const { fieldLengths, tokensByField } = indexDocument(
+        state,
+        docId,
+        document,
+        flatSchema,
+        language,
+        options
+      );
+      state.docStore.store(docId, document, fieldLengths);
+      state.stats.addDocument(fieldLengths, tokensByField);
+    },
+    remove(docId, schema, language, options) {
+      const stored = state.docStore.get(docId);
+      if (!stored) {
+        throw new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found in partition ${partitionId}`, {
+          docId,
+          partitionId
+        });
+      }
+      const flatSchema = getFlatSchema(state, schema);
+      const { fieldLengths, tokensByField } = removeFromIndexes(state, docId, stored, flatSchema, language, options);
+      state.docStore.remove(docId);
+      state.stats.removeDocument(fieldLengths, tokensByField);
+    },
+    update(docId, document, schema, language, options) {
+      const stored = state.docStore.get(docId);
+      if (!stored) {
+        throw new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found in partition ${partitionId}`, {
+          docId,
+          partitionId
+        });
+      }
+      if (options?.validate !== false) {
+        validateDocument(document, schema);
+      }
+      const flatSchema = getFlatSchema(state, schema);
+      const needsTextReindex = textFieldsChanged(stored.fields, document, flatSchema);
+      if (needsTextReindex) {
+        const { fieldLengths: oldFieldLengths, tokensByField: oldTokens } = removeFromIndexes(
+          state,
+          docId,
+          stored,
+          flatSchema,
+          language,
+          options
+        );
+        state.stats.removeDocument(oldFieldLengths, oldTokens);
+        state.docStore.remove(docId);
+        const { fieldLengths: newFieldLengths, tokensByField: newTokens } = indexDocument(
+          state,
+          docId,
+          document,
+          flatSchema,
+          language,
+          options
+        );
+        state.docStore.store(docId, document, newFieldLengths);
+        state.stats.addDocument(newFieldLengths, newTokens);
+      } else {
+        updateFieldIndexOnly(state, docId, stored.fields, document, flatSchema);
+        state.docStore.store(docId, document, stored.fieldLengths);
+      }
+    },
+    get(docId) {
+      const stored = state.docStore.get(docId);
+      if (!stored) return void 0;
+      return structuredClone(stored.fields);
+    },
+    has(docId) {
+      return state.docStore.has(docId);
+    },
+    count() {
+      return state.docStore.count();
+    },
+    *docIds() {
+      for (const [id] of state.docStore.all()) {
+        yield id;
+      }
+    },
+    clear: clearAll,
+    searchFulltext(params) {
+      return searchFulltext(state, params);
+    },
+    searchVector(params) {
+      return searchVector(state, params);
+    },
+    applyFilters(filters, schema) {
+      return applyPartitionFilters(state, filters, schema);
+    },
+    computeFacets(docIds, config, schema) {
+      return computeFacets(state, docIds, config, schema);
+    },
+    serialize(indexName, totalPartitions, language, schema) {
+      return serializePartition(state, partitionId, indexName, totalPartitions, language, schema);
+    },
+    deserialize(data, schema) {
+      deserializePartition(state, data, clearAll, schema);
+    }
+  };
+  return partition;
+}
+
+// src/partitioning/manager.ts
+function createPartitionManager(indexName, config, language, router, initialPartitionCount) {
+  const count = initialPartitionCount ?? 1;
+  let partitions = [];
+  const docPartitionMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    partitions.push(createPartitionIndex(i));
+  }
+  function validatePartitionId(partitionId) {
+    if (partitionId < 0 || partitionId >= partitions.length) {
+      throw new NarsilError(
+        ErrorCodes.INDEX_NOT_FOUND,
+        `Partition ${partitionId} is out of bounds (0..${partitions.length - 1})`,
+        { partitionId, partitionCount: partitions.length }
+      );
+    }
+  }
+  function rebuildDocPartitionMap() {
+    docPartitionMap.clear();
+    for (let i = 0; i < partitions.length; i++) {
+      for (const docId of partitions[i].docIds()) {
+        docPartitionMap.set(docId, i);
+      }
+    }
+  }
+  function rebuildDocPartitionMapForPartition(partitionId) {
+    for (const [docId, pid] of docPartitionMap) {
+      if (pid === partitionId) {
+        docPartitionMap.delete(docId);
+      }
+    }
+    for (const docId of partitions[partitionId].docIds()) {
+      docPartitionMap.set(docId, partitionId);
+    }
+  }
+  const manager = {
+    get partitionCount() {
+      return partitions.length;
+    },
+    get indexName() {
+      return indexName;
+    },
+    get schema() {
+      return config.schema;
+    },
+    get language() {
+      return language;
+    },
+    get config() {
+      return config;
+    },
+    getPartition(partitionId) {
+      validatePartitionId(partitionId);
+      return partitions[partitionId];
+    },
+    getAllPartitions() {
+      return [...partitions];
+    },
+    setPartitions(newPartitions) {
+      partitions = [...newPartitions];
+      rebuildDocPartitionMap();
+    },
+    addPartition() {
+      const partition = createPartitionIndex(partitions.length);
+      partitions.push(partition);
+      return partition;
+    },
+    removePartition(partitionId) {
+      validatePartitionId(partitionId);
+      partitions.splice(partitionId, 1);
+      rebuildDocPartitionMap();
+    },
+    insert(docId, document, options) {
+      const pid = router.route(docId, partitions.length);
+      partitions[pid].insert(docId, document, config.schema, language, options);
+      docPartitionMap.set(docId, pid);
+    },
+    remove(docId) {
+      const pid = docPartitionMap.get(docId);
+      if (pid === void 0) {
+        throw new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found in any partition`, { docId });
+      }
+      partitions[pid].remove(docId, config.schema, language);
+      docPartitionMap.delete(docId);
+    },
+    update(docId, document, options) {
+      const pid = docPartitionMap.get(docId);
+      if (pid === void 0) {
+        throw new NarsilError(ErrorCodes.DOC_NOT_FOUND, `Document "${docId}" not found in any partition`, { docId });
+      }
+      partitions[pid].update(docId, document, config.schema, language, options);
+    },
+    get(docId) {
+      const pid = docPartitionMap.get(docId);
+      if (pid === void 0) return void 0;
+      return partitions[pid].get(docId);
+    },
+    has(docId) {
+      return docPartitionMap.has(docId);
+    },
+    countDocuments() {
+      return docPartitionMap.size;
+    },
+    serializePartition(partitionId) {
+      validatePartitionId(partitionId);
+      return partitions[partitionId].serialize(indexName, partitions.length, language.name, config.schema);
+    },
+    deserializePartition(partitionId, data) {
+      validatePartitionId(partitionId);
+      partitions[partitionId].deserialize(data, config.schema);
+      rebuildDocPartitionMapForPartition(partitionId);
+    },
+    getAggregateStats() {
+      let totalDocuments = 0;
+      const docFrequencies = {};
+      const totalFieldLengths = {};
+      for (let i = 0; i < partitions.length; i++) {
+        const stats = partitions[i].stats;
+        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;
+        }
+      }
+      return { totalDocuments, docFrequencies, totalFieldLengths };
+    }
+  };
+  return manager;
+}
+
+// src/core/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var encoder = new TextEncoder();
+function fnv1a(input) {
+  const bytes = encoder.encode(input);
+  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;
+}
+
+// src/partitioning/router.ts
+function createPartitionRouter() {
+  function route(docId, partitionCount) {
+    if (partitionCount <= 0) {
+      throw new NarsilError(
+        ErrorCodes.INDEX_NOT_FOUND,
+        `Partition count must be greater than 0, received ${partitionCount}`,
+        { partitionCount }
+      );
+    }
+    return fnv1a(docId) % partitionCount;
+  }
+  function routeBatch(docIds, partitionCount) {
+    const groups = /* @__PURE__ */ new Map();
+    for (let i = 0; i < docIds.length; i++) {
+      const pid = route(docIds[i], partitionCount);
+      let group = groups.get(pid);
+      if (!group) {
+        group = [];
+        groups.set(pid, group);
+      }
+      group.push(docIds[i]);
+    }
+    return groups;
+  }
+  return { route, routeBatch };
+}
+
+// src/workers/direct-executor.ts
+function createDirectExecutor() {
+  const indexes = /* @__PURE__ */ new Map();
+  function requireIndex(indexName) {
+    const entry = indexes.get(indexName);
+    if (!entry) {
+      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" does not exist`, {
+        indexName
+      });
+    }
+    return entry;
+  }
+  function createIndex(indexName, config, language) {
+    if (indexes.has(indexName)) {
+      throw new NarsilError(ErrorCodes.INDEX_ALREADY_EXISTS, `Index "${indexName}" already exists`, {
+        indexName
+      });
+    }
+    const router = createPartitionRouter();
+    const partitionCount = config.partitions?.maxPartitions ?? 1;
+    const manager = createPartitionManager(indexName, config, language, router, partitionCount);
+    indexes.set(indexName, { manager, config, language });
+  }
+  function dropIndex(indexName) {
+    const entry = requireIndex(indexName);
+    for (const partition of entry.manager.getAllPartitions()) {
+      partition.clear();
+    }
+    indexes.delete(indexName);
+  }
+  function listIndexes() {
+    return Array.from(indexes.keys());
+  }
+  function getManager(indexName) {
+    return indexes.get(indexName)?.manager;
+  }
+  async function execute(action) {
+    switch (action.type) {
+      case "createIndex": {
+        const language = getLanguage(action.config.language ?? "english");
+        createIndex(action.indexName, action.config, language);
+        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);
+        return void 0;
+      }
+      case "remove": {
+        const entry = requireIndex(action.indexName);
+        entry.manager.remove(action.docId);
+        return void 0;
+      }
+      case "update": {
+        const entry = requireIndex(action.indexName);
+        entry.manager.update(action.docId, action.document);
+        return void 0;
+      }
+      case "query": {
+        const entry = requireIndex(action.indexName);
+        const result = fanOutQuery(entry.manager, action.params, entry.language, entry.config.schema, {
+          scoringMode: entry.config.defaultScoring ?? "local"
+        });
+        return result;
+      }
+      case "preflight": {
+        const entry = requireIndex(action.indexName);
+        const result = fanOutQuery(entry.manager, action.params, entry.language, entry.config.schema, {
+          scoringMode: entry.config.defaultScoring ?? "local"
+        });
+        return { count: result.totalMatched };
+      }
+      case "get": {
+        const entry = requireIndex(action.indexName);
+        return entry.manager.get(action.docId);
+      }
+      case "has": {
+        const entry = requireIndex(action.indexName);
+        return entry.manager.has(action.docId);
+      }
+      case "count": {
+        const entry = requireIndex(action.indexName);
+        return entry.manager.countDocuments();
+      }
+      case "getStats": {
+        const entry = requireIndex(action.indexName);
+        return {
+          documentCount: entry.manager.countDocuments(),
+          partitionCount: entry.manager.partitionCount,
+          language: entry.language.name,
+          schema: entry.config.schema
+        };
+      }
+      case "clear": {
+        const entry = requireIndex(action.indexName);
+        const partitions = entry.manager.getAllPartitions();
+        for (const partition of partitions) {
+          partition.clear();
+        }
+        entry.manager.setPartitions(partitions);
+        return void 0;
+      }
+      case "serialize": {
+        const entry = requireIndex(action.indexName);
+        return entry.manager.serializePartition(action.partitionId);
+      }
+      case "deserialize": {
+        const entry = requireIndex(action.indexName);
+        entry.manager.deserializePartition(action.partitionId, action.data);
+        return void 0;
+      }
+      case "memoryReport": {
+        const report = typeof process !== "undefined" && process.memoryUsage ? process.memoryUsage() : {};
+        return report;
+      }
+      case "shutdown": {
+        for (const [, entry] of indexes) {
+          for (const partition of entry.manager.getAllPartitions()) {
+            partition.clear();
+          }
+        }
+        indexes.clear();
+        return void 0;
+      }
+    }
+  }
+  async function shutdown() {
+    await execute({ type: "shutdown"});
+  }
+  return {
+    execute,
+    shutdown,
+    getManager,
+    createIndex,
+    dropIndex,
+    listIndexes
+  };
+}
+
+export { createDirectExecutor, fanOutQuery, getLanguage, registerLanguage, tokenize, validateSchema };