@delali/narsil 0.1.11 → 0.1.12

package/dist/index.browser.mjs

@@ -129,6 +129,7 @@ function computeDefaultCacheSize() {
   return Math.max(CACHE_SIZE_FLOOR, Math.min(2e5, CACHE_SIZE_CEILING));
 }
 var normalizationCache = /* @__PURE__ */ new Map();
+var normalizationCacheSize = 0;
 var maxCacheSize = computeDefaultCacheSize();
 function configureNormalizationCache(maxSize) {
   if (!Number.isFinite(maxSize)) {
@@ -151,19 +152,13 @@ function configureNormalizationCache(maxSize) {
     );
   }
   maxCacheSize = Math.max(CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), CACHE_SIZE_CEILING));
-  if (normalizationCache.size > maxCacheSize) {
-    const excess = normalizationCache.size - maxCacheSize;
-    let count = 0;
-    for (const key of normalizationCache.keys()) {
-      if (count >= excess) break;
-      normalizationCache.delete(key);
-      count++;
-    }
+  if (normalizationCacheSize > maxCacheSize) {
+    evictOldestEntries(normalizationCacheSize - maxCacheSize);
   }
 }
 var cachedLangName = "";
 var cachedFlags = "";
-var cachedPrefix = "";
+var cachedBucket = null;
 function stripDiacritics(text) {
   return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
 }
@@ -172,18 +167,44 @@ function resolveStopWords(language, override) {
   if (override instanceof Set) return override;
   return override(language.stopWords);
 }
-function getCachePrefix(language, flags) {
-  if (language.name === cachedLangName && flags === cachedFlags) return cachedPrefix;
+function getCacheBucket(language, flags) {
+  if (cachedBucket && language.name === cachedLangName && flags === cachedFlags) return cachedBucket;
+  const key = `${language.name}:${flags}`;
+  let bucket = normalizationCache.get(key);
+  if (!bucket) {
+    bucket = /* @__PURE__ */ new Map();
+    normalizationCache.set(key, bucket);
+  }
   cachedLangName = language.name;
   cachedFlags = flags;
-  cachedPrefix = `${language.name}:${flags}:`;
-  return cachedPrefix;
+  cachedBucket = bucket;
+  return bucket;
+}
+function evictOldestEntries(count) {
+  let remaining = count;
+  for (const [key, bucket] of normalizationCache) {
+    if (remaining <= 0) break;
+    if (bucket.size <= remaining) {
+      remaining -= bucket.size;
+      normalizationCacheSize -= bucket.size;
+      normalizationCache.delete(key);
+      if (bucket === cachedBucket) cachedBucket = null;
+    } else {
+      let deleted = 0;
+      for (const raw of bucket.keys()) {
+        if (deleted >= remaining) break;
+        bucket.delete(raw);
+        deleted++;
+      }
+      normalizationCacheSize -= deleted;
+      remaining = 0;
+    }
+  }
 }
 function transformToken(raw, language, stem, removeDiacritics) {
   const flags = (stem ? "s" : "") + (removeDiacritics ? "d" : "");
-  const prefix = getCachePrefix(language, flags);
-  const cacheKey = prefix + raw;
-  const cached = normalizationCache.get(cacheKey);
+  let bucket = getCacheBucket(language, flags);
+  const cached = bucket.get(raw);
   if (cached !== void 0) return cached;
   let normalized = raw;
   if (removeDiacritics) {
@@ -192,16 +213,12 @@ function transformToken(raw, language, stem, removeDiacritics) {
   if (stem && language.stemmer) {
     normalized = language.stemmer(normalized);
   }
-  if (normalizationCache.size >= maxCacheSize) {
-    const evictCount = Math.max(1, maxCacheSize >>> 2);
-    let count = 0;
-    for (const key of normalizationCache.keys()) {
-      if (count >= evictCount) break;
-      normalizationCache.delete(key);
-      count++;
-    }
+  if (normalizationCacheSize >= maxCacheSize) {
+    evictOldestEntries(Math.max(1, maxCacheSize >>> 2));
+    bucket = getCacheBucket(language, flags);
   }
-  normalizationCache.set(cacheKey, normalized);
+  bucket.set(raw, normalized);
+  normalizationCacheSize++;
   return normalized;
 }
 function splitText(text, language) {
@@ -231,24 +248,28 @@ function tokenize(text, language, options) {
     stem = true,
     removeStopWords = true,
     removeDiacritics = false,
+    collectSurfaces = false,
     customTokenizer,
     stopWordOverride
   } = options ?? {};
   if (customTokenizer) {
     const customResult = customTokenizer.tokenize(text);
+    const originals = customResult.map((t) => t.token);
     return {
       tokens: customResult,
-      originalTokens: customResult.map((t) => t.token)
+      originalTokens: originals
     };
   }
   const normalized = isAscii(text) ? text.toLowerCase() : 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 stemsTokens = stem && language.stemmer !== void 0;
   const stopWords2 = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
   const stripPossessives = language.tokenizer?.stripPossessive ?? false;
   const tokens = [];
   const originalTokens = [];
+  const surfaces = collectSurfaces && stemsTokens ? [] : void 0;
   let position = 0;
   for (const part of rawParts) {
     const candidate = stripPossessives ? stripPossessive(part) : part;
@@ -264,16 +285,21 @@ function tokenize(text, language, options) {
     if (processed.length > 0) {
       tokens.push({ token: processed, position });
       originalTokens.push(part);
+      if (surfaces) {
+        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
+        surfaces.push(surface === processed ? void 0 : surface);
+      }
     }
     position++;
   }
-  return { tokens, originalTokens };
+  return { tokens, originalTokens, surfaces };
 }
 function* tokenizeIterator(text, language, options) {
   const {
     stem = true,
     removeStopWords = true,
     removeDiacritics = false,
+    collectSurfaces = false,
     customTokenizer,
     stopWordOverride
   } = options ?? {};
@@ -288,6 +314,8 @@ function* tokenizeIterator(text, language, options) {
   const rawParts = splitText(normalized, language);
   const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
   const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
+  const stemsTokens = stem && language.stemmer !== void 0;
+  const wantSurfaces = collectSurfaces && stemsTokens;
   const stopWords2 = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
   const stripPossessives = language.tokenizer?.stripPossessive ?? false;
   let position = 0;
@@ -303,20 +331,27 @@ function* tokenizeIterator(text, language, options) {
     }
     const processed = transformToken(candidate, language, stem, effectiveDiacritics);
     if (processed.length > 0) {
-      yield { token: processed, position };
+      if (wantSurfaces) {
+        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
+        yield { token: processed, position, surface: surface === processed ? void 0 : surface };
+      } else {
+        yield { token: processed, position };
+      }
     }
     position++;
   }
 }
 function clearNormalizationCache() {
   normalizationCache.clear();
+  normalizationCacheSize = 0;
+  cachedBucket = null;
 }
 function resetNormalizationCache() {
-  normalizationCache.clear();
+  clearNormalizationCache();
   maxCacheSize = computeDefaultCacheSize();
 }
 function getNormalizationCacheSize() {
-  return normalizationCache.size;
+  return normalizationCacheSize;
 }
 
 // src/languages/english.ts
@@ -1081,8 +1116,20 @@ function validateVectorPromotion(config) {
     fail("vectorPromotion.hnswConfig.metric must be 'cosine', 'dotProduct', or 'euclidean'", { metric });
   }
 }
-function encodeRawPayloadV2(wire) {
-  return encode(wire);
+function sanitizeSurfaceForms(raw) {
+  if (raw === void 0 || raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const result = /* @__PURE__ */ Object.create(null);
+  let count = 0;
+  for (const [surface, value] of Object.entries(raw)) {
+    if (typeof value === "number") {
+      result[surface] = value;
+      count++;
+    } else if (Array.isArray(value) && typeof value[0] === "number" && typeof value[1] === "string") {
+      result[surface] = [value[0], value[1]];
+      count++;
+    }
+  }
+  return count > 0 ? result : void 0;
 }
 var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function validateHnswMetric(value) {
@@ -1092,6 +1139,153 @@ function validateHnswMetric(value) {
   }
   return void 0;
 }
+function wireToPartition(raw) {
+  const documents = {};
+  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
+    documents[docId] = {
+      fields: doc.fields,
+      fieldLengths: doc.field_lengths ?? {}
+    };
+  }
+  const invertedIndex = {};
+  for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
+    invertedIndex[token] = {
+      docFrequency: list.doc_freq,
+      postings: (list.postings ?? []).map((p) => ({
+        docId: p.doc_id,
+        termFrequency: p.term_freq,
+        field: p.field,
+        positions: p.positions ?? []
+      }))
+    };
+  }
+  const numeric = {};
+  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
+    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
+  }
+  const boolean = {};
+  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
+    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
+  }
+  const geopoint = {};
+  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
+    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
+  }
+  const vectorData = {};
+  for (const [field, data] of Object.entries(raw.vector_data ?? {})) {
+    vectorData[field] = {
+      dimension: data.dimension,
+      vectors: (data.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
+      hnswGraph: data.hnsw_graph ? {
+        entryPoint: data.hnsw_graph.entry_point,
+        maxLayer: data.hnsw_graph.max_layer,
+        m: data.hnsw_graph.m,
+        efConstruction: data.hnsw_graph.ef_construction,
+        metric: validateHnswMetric(data.hnsw_graph.metric),
+        nodes: data.hnsw_graph.nodes
+      } : null,
+      sq8: data.sq8 ? {
+        alpha: data.sq8.alpha,
+        offset: data.sq8.offset,
+        quantizedVectors: data.sq8.quantized_vectors,
+        vectorSums: data.sq8.vector_sums,
+        vectorSumSqs: data.sq8.vector_sum_sqs
+      } : null
+    };
+  }
+  return {
+    indexName: raw.index_name,
+    partitionId: raw.partition_id,
+    totalPartitions: raw.total_partitions,
+    language: raw.language ?? "english",
+    schema: raw.schema ?? {},
+    docCount: raw.doc_count ?? 0,
+    avgDocLength: raw.avg_doc_length ?? 0,
+    documents,
+    invertedIndex,
+    fieldIndexes: {
+      numeric,
+      boolean,
+      enum: raw.field_indexes?.enum ?? {},
+      geopoint
+    },
+    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
+    vectorData,
+    statistics: {
+      totalDocuments: raw.statistics?.total_documents ?? 0,
+      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
+      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
+      docFrequencies: raw.statistics?.doc_frequencies ?? {}
+    }
+  };
+}
+function deserializePayloadV1(data) {
+  const raw = decode(data);
+  return wireToPartition(raw);
+}
+function metadataToWire(meta) {
+  const wire = {
+    index_name: meta.indexName,
+    schema: meta.schema,
+    language: meta.language,
+    partition_count: meta.partitionCount,
+    bm25_params: meta.bm25Params,
+    created_at: meta.createdAt,
+    engine_version: meta.engineVersion
+  };
+  if (meta.vectorFields) {
+    wire.vector_fields = meta.vectorFields;
+  }
+  if (meta.embedding) {
+    wire.embedding = meta.embedding.adapter !== void 0 ? { adapter: meta.embedding.adapter, fields: meta.embedding.fields } : { fields: meta.embedding.fields };
+  }
+  if (meta.surfaceForms === true) {
+    wire.surface_forms_enabled = true;
+  }
+  return wire;
+}
+function wireToMetadata(raw) {
+  const meta = {
+    indexName: raw.index_name,
+    schema: raw.schema ?? {},
+    language: raw.language ?? "english",
+    partitionCount: raw.partition_count ?? 1,
+    bm25Params: raw.bm25_params ?? { k1: 1.2, b: 0.75 },
+    createdAt: raw.created_at ?? 0,
+    engineVersion: raw.engine_version ?? "0.0.0"
+  };
+  if (raw.vector_fields) {
+    meta.vectorFields = raw.vector_fields;
+  }
+  if (raw.embedding && typeof raw.embedding === "object" && typeof raw.embedding.fields === "object") {
+    meta.embedding = typeof raw.embedding.adapter === "string" ? { adapter: raw.embedding.adapter, fields: raw.embedding.fields } : { fields: raw.embedding.fields };
+  }
+  if (raw.surface_forms_enabled === true) {
+    meta.surfaceForms = true;
+  }
+  return meta;
+}
+function serializeMetadata(meta) {
+  const wire = metadataToWire(meta);
+  return encode(wire);
+}
+function deserializeMetadata(data) {
+  const raw = decode(data);
+  return wireToMetadata(raw);
+}
+
+// src/serialization/payload-v2.ts
+function encodeRawPayloadV2(wire) {
+  return encode(wire);
+}
+var VALID_HNSW_METRICS2 = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
+function validateHnswMetric2(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string" && VALID_HNSW_METRICS2.has(value)) {
+    return value;
+  }
+  return void 0;
+}
 function deserializePayloadV2(data) {
   const raw = decode(data);
   const documents = {};
@@ -1141,7 +1335,7 @@ function deserializePayloadV2(data) {
         maxLayer: data2.hnsw_graph.max_layer,
         m: data2.hnsw_graph.m,
         efConstruction: data2.hnsw_graph.ef_construction,
-        metric: validateHnswMetric(data2.hnsw_graph.metric),
+        metric: validateHnswMetric2(data2.hnsw_graph.metric),
         nodes: data2.hnsw_graph.nodes
       } : null,
       sq8: data2.sq8 ? {
@@ -1169,6 +1363,7 @@ function deserializePayloadV2(data) {
       enum: raw.field_indexes?.enum ?? {},
       geopoint
     },
+    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
     vectorData,
     statistics: {
       totalDocuments: raw.statistics?.total_documents ?? 0,
@@ -1384,7 +1579,8 @@ function createInvertedIndex(fieldNameTable) {
         fieldNameIndices: new Uint8Array(INITIAL_CAPACITY),
         positions: null,
         docIdSet: /* @__PURE__ */ new Set(),
-        deletedDocs: /* @__PURE__ */ new Set()
+        deletedDocs: /* @__PURE__ */ new Set(),
+        totalTermFrequency: 0
       };
       index.set(token, list);
       trackToken(token);
@@ -1414,6 +1610,8 @@ function createInvertedIndex(fieldNameTable) {
           }
         }
         writeIdx++;
+      } else {
+        list.totalTermFrequency -= list.termFrequencies[i];
       }
     }
     list.docIds.length = writeIdx;
@@ -1434,6 +1632,8 @@ function createInvertedIndex(fieldNameTable) {
           }
         }
         writeIdx++;
+      } else {
+        list.totalTermFrequency -= list.termFrequencies[i];
       }
     }
     list.docIds.length = writeIdx;
@@ -1454,6 +1654,7 @@ function createInvertedIndex(fieldNameTable) {
       list.docIds.push(internalId);
       list.termFrequencies[idx] = termFrequency > MAX_TERM_FREQUENCY ? MAX_TERM_FREQUENCY : termFrequency;
       list.fieldNameIndices[idx] = fieldNameIndex;
+      list.totalTermFrequency += list.termFrequencies[idx];
       if (positions !== null) {
         if (!list.positions) {
           list.positions = [];
@@ -1581,12 +1782,14 @@ function createInvertedIndex(fieldNameTable) {
         const fieldNameIndices = new Uint8Array(count);
         let hasPositions = false;
         let validCount = 0;
+        let totalTermFrequency = 0;
         for (let i = 0; i < count; i++) {
           const p = src.postings[i];
           const internalId = resolver.toInternal(p.docId);
           if (internalId === void 0) continue;
           docIds[validCount] = internalId;
           termFrequencies[validCount] = p.termFrequency > MAX_TERM_FREQUENCY ? MAX_TERM_FREQUENCY : p.termFrequency;
+          totalTermFrequency += termFrequencies[validCount];
           let fnIndex = fieldNameTable.indexMap.get(p.fieldName);
           if (fnIndex === void 0) {
             fnIndex = fieldNameTable.names.length;
@@ -1620,7 +1823,8 @@ function createInvertedIndex(fieldNameTable) {
           fieldNameIndices: finalFNI,
           positions,
           docIdSet,
-          deletedDocs: /* @__PURE__ */ new Set()
+          deletedDocs: /* @__PURE__ */ new Set(),
+          totalTermFrequency
         });
         trackToken(token);
       }
@@ -1762,6 +1966,115 @@ function createPartitionStats() {
   return stats;
 }
 
+// src/core/surface-registry.ts
+function createSurfaceRegistry() {
+  const entries = /* @__PURE__ */ new Map();
+  const buckets = /* @__PURE__ */ new Map();
+  let totalsByToken = null;
+  function track(surface) {
+    const ch = surface[0];
+    let bucket = buckets.get(ch);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      buckets.set(ch, bucket);
+    }
+    bucket.add(surface);
+  }
+  function untrack(surface) {
+    const ch = surface[0];
+    const bucket = buckets.get(ch);
+    if (bucket) {
+      bucket.delete(surface);
+      if (bucket.size === 0) buckets.delete(ch);
+    }
+  }
+  function adjustTotals(token, delta) {
+    if (!totalsByToken || delta === 0) return;
+    const next = (totalsByToken.get(token) ?? 0) + delta;
+    if (next <= 0) totalsByToken.delete(token);
+    else totalsByToken.set(token, next);
+  }
+  return {
+    add(surface, token, occurrences) {
+      if (surface.length === 0 || token.length === 0 || occurrences <= 0) return;
+      if (surface === token) return;
+      const existing = entries.get(surface);
+      if (existing) {
+        existing.count += occurrences;
+        adjustTotals(existing.token, occurrences);
+        return;
+      }
+      entries.set(surface, { token, count: occurrences });
+      track(surface);
+      adjustTotals(token, occurrences);
+    },
+    subtract(surface, occurrences) {
+      if (occurrences <= 0) return;
+      const existing = entries.get(surface);
+      if (!existing) return;
+      const removed = Math.min(occurrences, existing.count);
+      existing.count -= occurrences;
+      adjustTotals(existing.token, -removed);
+      if (existing.count <= 0) {
+        entries.delete(surface);
+        untrack(surface);
+      }
+    },
+    candidatesForPrefix(prefix) {
+      if (prefix.length === 0) return [];
+      const bucket = buckets.get(prefix[0]);
+      if (!bucket) return [];
+      const results = [];
+      for (const surface of bucket) {
+        if (surface.length < prefix.length || !surface.startsWith(prefix)) continue;
+        const entry = entries.get(surface);
+        if (!entry) continue;
+        results.push({ surface, token: entry.token, occurrences: entry.count });
+      }
+      return results;
+    },
+    stemChangedTotalFor(token) {
+      if (!totalsByToken) {
+        totalsByToken = /* @__PURE__ */ new Map();
+        for (const entry of entries.values()) {
+          totalsByToken.set(entry.token, (totalsByToken.get(entry.token) ?? 0) + entry.count);
+        }
+      }
+      return totalsByToken.get(token) ?? 0;
+    },
+    size() {
+      return entries.size;
+    },
+    clear() {
+      entries.clear();
+      buckets.clear();
+      totalsByToken = null;
+    },
+    serialize() {
+      const result = /* @__PURE__ */ Object.create(null);
+      for (const [surface, entry] of entries) {
+        result[surface] = [entry.count, entry.token];
+      }
+      return result;
+    },
+    deserialize(data) {
+      entries.clear();
+      buckets.clear();
+      totalsByToken = null;
+      for (const surface of Object.keys(data)) {
+        if (surface.length === 0) continue;
+        const value = data[surface];
+        if (!Array.isArray(value) || typeof value[0] !== "number" || typeof value[1] !== "string") continue;
+        const count = value[0];
+        const token = value[1];
+        if (!Number.isFinite(count) || count <= 0 || token.length === 0 || token === surface) continue;
+        entries.set(surface, { token, count: Math.floor(count) });
+        track(surface);
+      }
+    }
+  };
+}
+
 // src/core/partition/utils.ts
 function getOrCreateFieldNameIndex(table, fieldName) {
   const existing = table.indexMap.get(fieldName);
@@ -1806,6 +2119,7 @@ function tokenizeOptions(options) {
   return {
     stem: true,
     removeStopWords: true,
+    collectSurfaces: options?.collectSurfaces === true,
     stopWordOverride: options?.stopWordOverride,
     customTokenizer: options?.customTokenizer
   };
@@ -1891,32 +2205,177 @@ function computeFacets(state, docIds, config, schema) {
   return result;
 }
 
-// src/core/bitset.ts
-function createBitSet(capacity) {
-  return new Uint32Array(capacity + 31 >>> 5 || 1);
-}
-function bitsetSet(bs, index) {
-  const word = index >>> 5;
-  if (word < bs.length) {
-    bs[word] |= 1 << (index & 31);
-  }
-}
-function bitsetHas(bs, index) {
-  const word = index >>> 5;
-  if (word >= bs.length) return false;
-  return (bs[word] & 1 << (index & 31)) !== 0;
+// 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;
 }
-function bitsetAnd(a, b) {
-  const len = Math.min(a.length, b.length);
-  const result = new Uint32Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = a[i] & b[i];
+
+// 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 result;
+  return inside;
 }
-function bitsetOr(a, b) {
-  const longer = a.length >= b.length ? a : b;
-  const shorter = a.length >= b.length ? b : a;
+
+// 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(internalId, lat, lon) {
+      entries.push({ lat, lon, docId: internalId });
+    },
+    remove(internalId) {
+      for (let i = entries.length - 1; i >= 0; i--) {
+        if (entries[i].docId === internalId) {
+          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/core/bitset.ts
+function createBitSet(capacity) {
+  return new Uint32Array(capacity + 31 >>> 5 || 1);
+}
+function bitsetSet(bs, index) {
+  const word = index >>> 5;
+  if (word < bs.length) {
+    bs[word] |= 1 << (index & 31);
+  }
+}
+function bitsetHas(bs, index) {
+  const word = index >>> 5;
+  if (word >= bs.length) return false;
+  return (bs[word] & 1 << (index & 31)) !== 0;
+}
+function bitsetAnd(a, b) {
+  const len = Math.min(a.length, b.length);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = a[i] & b[i];
+  }
+  return result;
+}
+function bitsetOr(a, b) {
+  const longer = a.length >= b.length ? a : b;
+  const shorter = a.length >= b.length ? b : a;
   const result = new Uint32Array(longer.length);
   for (let i = 0; i < shorter.length; i++) {
     result[i] = longer[i] | shorter[i];
@@ -1952,1197 +2411,1096 @@ function bitsetFromSet(set, capacity) {
   return bs;
 }
 
-// src/filters/combinators.ts
-function applyAndBitset(bitsets) {
-  if (bitsets.length === 0) return new Uint32Array(0);
-  if (bitsets.length === 1) return bitsets[0];
-  let result = bitsets[0];
-  for (let i = 1; i < bitsets.length; i++) {
-    result = bitsetAnd(result, bitsets[i]);
-  }
-  return result;
-}
-function applyOrBitset(bitsets) {
-  if (bitsets.length === 0) return new Uint32Array(0);
-  if (bitsets.length === 1) return bitsets[0];
-  let result = bitsets[0];
-  for (let i = 1; i < bitsets.length; i++) {
-    result = bitsetOr(result, bitsets[i]);
-  }
-  return result;
-}
-function applyNotBitset(excluded, capacity) {
-  return bitsetNot(excluded, capacity);
-}
-
-// src/filters/operators/shared.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 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/operators/bitset.ts
-function resolveBitset(bs) {
-  return typeof bs === "function" ? bs() : bs;
-}
-function scanToBitset(docIds, capacity, getValue, predicate) {
-  const resolved = resolveBitset(docIds);
-  const result = createBitSet(capacity);
-  for (let wi = 0; wi < resolved.length; wi++) {
-    let word = resolved[wi];
-    if (word === 0) continue;
-    const base = wi << 5;
-    while (word !== 0) {
-      const tz = Math.clz32(word & -word) ^ 31;
-      const id = base + tz;
-      if (predicate(getValue(id))) {
-        bitsetSet(result, id);
+// src/core/field-index/boolean.ts
+function createBooleanIndex() {
+  const trueDocs = /* @__PURE__ */ new Set();
+  const falseDocs = /* @__PURE__ */ new Set();
+  return {
+    insert(internalId, value) {
+      if (value) trueDocs.add(internalId);
+      else falseDocs.add(internalId);
+    },
+    remove(internalId, value) {
+      if (value) trueDocs.delete(internalId);
+      else falseDocs.delete(internalId);
+    },
+    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;
+    },
+    queryEqBitset(value, capacity) {
+      const source = value ? trueDocs : falseDocs;
+      const bs = createBitSet(capacity);
+      for (const id of source) {
+        bitsetSet(bs, id);
       }
-      word &= word - 1;
+      return bs;
+    },
+    getAllDocIdsBitset(capacity) {
+      const bs = createBitSet(capacity);
+      for (const id of trueDocs) bitsetSet(bs, id);
+      for (const id of falseDocs) bitsetSet(bs, id);
+      return bs;
+    },
+    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);
     }
-  }
-  return result;
+  };
 }
-function applyEqBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric" && typeof value === "number") {
-    return fieldIndex.index.eqBitset(value, capacity);
-  }
-  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
-    return value ? fieldIndex.index.getTrueBitset(capacity) : fieldIndex.index.getFalseBitset(capacity);
-  }
-  if (fieldIndex?.type === "enum" && typeof value === "string") {
-    return fieldIndex.index.getDocIdsBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === value);
-}
-function applyNeBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric" && typeof value === "number") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const eq = fieldIndex.index.eqBitset(value, capacity);
-    return bitsetAnd(all, bitsetNot(eq, capacity));
-  }
-  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
-    return value ? fieldIndex.index.getFalseBitset(capacity) : fieldIndex.index.getTrueBitset(capacity);
-  }
-  if (fieldIndex?.type === "enum" && typeof value === "string") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const eq = fieldIndex.index.getDocIdsBitset(value, capacity);
-    return bitsetAnd(all, bitsetNot(eq, capacity));
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null && v !== value);
-}
-function applyGtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.gtBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v > value);
-}
-function applyLtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.ltBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v < value);
-}
-function applyGteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.gteBitset(value, capacity);
+
+// src/core/field-index/enum.ts
+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 scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= value);
+  return {
+    insert(internalId, value) {
+      let docSet = valueMap.get(value);
+      if (!docSet) {
+        docSet = /* @__PURE__ */ new Set();
+        valueMap.set(value, docSet);
+      }
+      docSet.add(internalId);
+    },
+    remove(internalId, value) {
+      const docSet = valueMap.get(value);
+      if (!docSet) return;
+      docSet.delete(internalId);
+      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();
+    },
+    queryEqBitset(value, capacity) {
+      const bs = createBitSet(capacity);
+      const docSet = valueMap.get(value);
+      if (docSet) {
+        for (const id of docSet) bitsetSet(bs, id);
+      }
+      return bs;
+    },
+    queryInBitset(values, capacity) {
+      const bs = createBitSet(capacity);
+      for (const val of values) {
+        const docSet = valueMap.get(val);
+        if (docSet) {
+          for (const id of docSet) bitsetSet(bs, id);
+        }
+      }
+      return bs;
+    },
+    getAllDocIdsBitset(capacity) {
+      const bs = createBitSet(capacity);
+      for (const docSet of valueMap.values()) {
+        for (const id of docSet) bitsetSet(bs, id);
+      }
+      return bs;
+    },
+    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]));
+      }
+    }
+  };
 }
-function applyLteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.lteBitset(value, capacity);
+
+// src/core/field-index/numeric.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 scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v <= value);
+  return lo;
 }
-function applyBetweenBitset(range, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.betweenBitset(range[0], range[1], capacity);
+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 scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= range[0] && v <= range[1]);
+  return lo;
 }
-function applyInBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "enum") {
-    return fieldIndex.index.getDocIdsInBitset(values, capacity);
+function collectDocIds(entries, from, to) {
+  const result = /* @__PURE__ */ new Set();
+  for (let i = from; i < to; i++) {
+    result.add(entries[i].docId);
   }
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && valSet.has(v));
+  return result;
 }
-function applyNinBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "enum") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const matched = fieldIndex.index.getDocIdsInBitset(values, capacity);
-    return bitsetAnd(all, bitsetNot(matched, capacity));
+function collectDocIdsBitset(entries, from, to, capacity) {
+  const bs = createBitSet(capacity);
+  for (let i = from; i < to; i++) {
+    bitsetSet(bs, entries[i].docId);
   }
-  const valSet = new Set(values);
-  return scanToBitset(
-    allDocsBitset,
-    capacity,
-    getValue,
-    (v) => v !== void 0 && v !== null && typeof v === "string" && !valSet.has(v)
-  );
-}
-function applyStartsWithBitset(prefix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.startsWith(prefix));
-}
-function applyEndsWithBitset(suffix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.endsWith(suffix));
-}
-function applyContainsAllBitset(values, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (!Array.isArray(v)) return false;
-    const arr = v;
-    for (const val of values) {
-      if (!arr.includes(val)) return false;
-    }
-    return true;
-  });
+  return bs;
 }
-function applyMatchesAnyBitset(values, allDocsBitset, capacity, getValue) {
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (!Array.isArray(v)) return false;
-    for (const item of v) {
-      if (valSet.has(item)) return true;
+function createNumericIndex() {
+  let entries = [];
+  let sorted = true;
+  function ensureSorted() {
+    if (!sorted) {
+      entries.sort((a, b) => a.value - b.value);
+      sorted = true;
     }
-    return false;
-  });
-}
-function applySizeBitset(sizeFilter, allDocsBitset, capacity, getValue) {
-  return scanToBitset(
-    allDocsBitset,
-    capacity,
-    getValue,
-    (v) => Array.isArray(v) && matchesNumericComparison(v.length, sizeFilter)
-  );
-}
-function applyExistsBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null);
-}
-function applyNotExistsBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === void 0 || v === null);
-}
-function applyIsEmptyBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (v === void 0 || v === null) return true;
-    if (typeof v === "string" && v === "") return true;
-    if (Array.isArray(v) && v.length === 0) return true;
-    return false;
-  });
-}
-function applyIsNotEmptyBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (v === void 0 || v === null) return false;
-    if (typeof v === "string" && v === "") return false;
-    if (Array.isArray(v) && v.length === 0) return false;
-    return true;
-  });
-}
-function applyGeoRadiusBitset(filter, geoIndex, capacity) {
-  const distanceMeters = convertToMeters(filter.distance, filter.unit);
-  const setResult = geoIndex.radiusQuery(
-    filter.lat,
-    filter.lon,
-    distanceMeters,
-    filter.inside ?? true,
-    filter.highPrecision ?? false
-  );
-  return bitsetFromSet(setResult, capacity);
-}
-function applyGeoPolygonBitset(filter, geoIndex, capacity) {
-  const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
-  return bitsetFromSet(setResult, capacity);
+  }
+  return {
+    insert(internalId, value) {
+      entries.push({ value, docId: internalId });
+      sorted = false;
+    },
+    remove(internalId, value) {
+      ensureSorted();
+      const start = lowerBound(entries, value);
+      const end = upperBound(entries, value);
+      for (let i = start; i < end; i++) {
+        if (entries[i].docId === internalId) {
+          entries.splice(i, 1);
+          return;
+        }
+      }
+    },
+    queryEq(value) {
+      ensureSorted();
+      return collectDocIds(entries, lowerBound(entries, value), upperBound(entries, value));
+    },
+    queryNe(value) {
+      ensureSorted();
+      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) {
+      ensureSorted();
+      return collectDocIds(entries, upperBound(entries, value), entries.length);
+    },
+    queryGte(value) {
+      ensureSorted();
+      return collectDocIds(entries, lowerBound(entries, value), entries.length);
+    },
+    queryLt(value) {
+      ensureSorted();
+      return collectDocIds(entries, 0, lowerBound(entries, value));
+    },
+    queryLte(value) {
+      ensureSorted();
+      return collectDocIds(entries, 0, upperBound(entries, value));
+    },
+    queryBetween(min, max) {
+      ensureSorted();
+      return collectDocIds(entries, lowerBound(entries, min), upperBound(entries, max));
+    },
+    getAllDocIds() {
+      return collectDocIds(entries, 0, entries.length);
+    },
+    queryEqBitset(value, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, lowerBound(entries, value), upperBound(entries, value), capacity);
+    },
+    queryGtBitset(value, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, upperBound(entries, value), entries.length, capacity);
+    },
+    queryGteBitset(value, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, lowerBound(entries, value), entries.length, capacity);
+    },
+    queryLtBitset(value, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, 0, lowerBound(entries, value), capacity);
+    },
+    queryLteBitset(value, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, 0, upperBound(entries, value), capacity);
+    },
+    queryBetweenBitset(min, max, capacity) {
+      ensureSorted();
+      return collectDocIdsBitset(entries, lowerBound(entries, min), upperBound(entries, max), capacity);
+    },
+    getAllDocIdsBitset(capacity) {
+      return collectDocIdsBitset(entries, 0, entries.length, capacity);
+    },
+    count() {
+      return entries.length;
+    },
+    clear() {
+      entries = [];
+      sorted = true;
+    },
+    serialize() {
+      ensureSorted();
+      return entries.slice();
+    },
+    deserialize(data) {
+      entries = data.slice();
+      sorted = true;
+    }
+  };
 }
 
-// src/filters/evaluator.ts
-function evaluateFilters(expression, context) {
-  const bitsets = [];
-  if (expression.fields) {
-    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
-      bitsets.push(evaluateFieldFilter(fieldPath, filter, context));
-    }
-  }
-  if (expression.and?.length) {
-    const andBitsets = expression.and.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyAndBitset(andBitsets));
-  }
-  if (expression.or?.length) {
-    const orBitsets = expression.or.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyOrBitset(orBitsets));
-  }
-  if (expression.not) {
-    const excluded = evaluateFilters(expression.not, context);
-    const universe = context.allDocIdsBitset;
-    bitsets.push(applyAndBitset([universe, applyNotBitset(excluded, context.capacity)]));
+// 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());
   }
-  if (bitsets.length === 0) return context.allDocIdsBitset;
-  if (bitsets.length === 1) return bitsets[0];
-  return applyAndBitset(bitsets);
 }
-function evaluateFieldFilter(fieldPath, filter, context) {
-  const fieldIndex = context.fieldIndexes[fieldPath];
-  const getValue = (internalId) => context.getFieldValue(internalId, fieldPath);
-  const f = filter;
-  const bitsets = [];
-  const { capacity } = context;
-  let allDocsBitset = null;
-  const getAllDocsBitset = () => {
-    if (allDocsBitset === null) {
-      allDocsBitset = context.allDocIdsBitset;
-    }
-    return allDocsBitset;
-  };
-  if ("radius" in f && f.radius) {
-    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
-    bitsets.push(applyGeoRadiusBitset(filter.radius, geoIndex, capacity));
-  }
-  if ("polygon" in f && f.polygon) {
-    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
-    bitsets.push(applyGeoPolygonBitset(filter.polygon, geoIndex, capacity));
-  }
-  if ("eq" in f && f.eq !== void 0) {
-    bitsets.push(applyEqBitset(f.eq, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("ne" in f && f.ne !== void 0) {
-    bitsets.push(applyNeBitset(f.ne, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("gt" in f && f.gt !== void 0) {
-    bitsets.push(applyGtBitset(f.gt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("lt" in f && f.lt !== void 0) {
-    bitsets.push(applyLtBitset(f.lt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("gte" in f && f.gte !== void 0) {
-    bitsets.push(applyGteBitset(f.gte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("lte" in f && f.lte !== void 0) {
-    bitsets.push(applyLteBitset(f.lte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("between" in f && f.between !== void 0) {
-    bitsets.push(applyBetweenBitset(f.between, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("in" in f && f.in !== void 0) {
-    bitsets.push(applyInBitset(f.in, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("nin" in f && f.nin !== void 0) {
-    bitsets.push(applyNinBitset(f.nin, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("startsWith" in f && f.startsWith !== void 0) {
-    bitsets.push(applyStartsWithBitset(f.startsWith, getAllDocsBitset, capacity, getValue));
-  }
-  if ("endsWith" in f && f.endsWith !== void 0) {
-    bitsets.push(applyEndsWithBitset(f.endsWith, getAllDocsBitset, capacity, getValue));
-  }
-  if ("containsAll" in f && f.containsAll !== void 0) {
-    bitsets.push(
-      applyContainsAllBitset(f.containsAll, getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("matchesAny" in f && f.matchesAny !== void 0) {
-    bitsets.push(
-      applyMatchesAnyBitset(f.matchesAny, getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("size" in f && f.size !== void 0) {
-    bitsets.push(applySizeBitset(f.size, getAllDocsBitset, capacity, getValue));
-  }
-  if ("exists" in f && f.exists !== void 0) {
-    bitsets.push(
-      f.exists ? applyExistsBitset(getAllDocsBitset, capacity, getValue) : applyNotExistsBitset(getAllDocsBitset, capacity, getValue)
-    );
+function getOrCreateNumericIndex(state, fieldPath) {
+  let idx = state.numericIndexes.get(fieldPath);
+  if (!idx) {
+    idx = createNumericIndex();
+    state.numericIndexes.set(fieldPath, idx);
   }
-  if ("notExists" in f && f.notExists !== void 0) {
-    bitsets.push(
-      f.notExists ? applyNotExistsBitset(getAllDocsBitset, capacity, getValue) : applyExistsBitset(getAllDocsBitset, capacity, getValue)
-    );
+  return idx;
+}
+function getOrCreateBooleanIndex(state, fieldPath) {
+  let idx = state.booleanIndexes.get(fieldPath);
+  if (!idx) {
+    idx = createBooleanIndex();
+    state.booleanIndexes.set(fieldPath, idx);
   }
-  if ("isEmpty" in f && f.isEmpty !== void 0) {
-    bitsets.push(
-      f.isEmpty ? applyIsEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue)
-    );
+  return idx;
+}
+function resolveInternalId(state, docId) {
+  const internalId = state.docStore.getInternalId(docId);
+  if (internalId === void 0) {
+    throw new Error(`Internal ID not found for document "${docId}"`);
   }
-  if ("isNotEmpty" in f && f.isNotEmpty !== void 0) {
-    bitsets.push(
-      f.isNotEmpty ? applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsEmptyBitset(getAllDocsBitset, capacity, getValue)
-    );
+  return internalId;
+}
+function countSurface(counts, surface, token) {
+  if (surface === void 0 || surface.length === 0) return;
+  const existing = counts.get(surface);
+  if (existing) {
+    existing.count++;
+  } else {
+    counts.set(surface, { token, count: 1 });
   }
-  if (bitsets.length === 0) return context.allDocIdsBitset;
-  if (bitsets.length === 1) return bitsets[0];
-  return applyAndBitset(bitsets);
 }
-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 }
-    );
+function applySurfaceCounts(state, counts, direction) {
+  for (const [surface, entry] of counts) {
+    if (direction === 1) {
+      state.surfaceRegistry.add(surface, entry.token, entry.count);
+    } else {
+      state.surfaceRegistry.subtract(surface, entry.count);
+    }
   }
-  return fieldIndex.index;
 }
-
-// src/core/partition/filters.ts
-function buildFilterContext(state, schema) {
-  const flat = getFlatSchema(state, schema);
-  const fieldIndexes = {};
-  const capacity = state.docStore.internalIdCapacity();
-  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(),
-            eqBitset: (v, cap) => numIdx.queryEqBitset(v, cap),
-            gtBitset: (v, cap) => numIdx.queryGtBitset(v, cap),
-            gteBitset: (v, cap) => numIdx.queryGteBitset(v, cap),
-            ltBitset: (v, cap) => numIdx.queryLtBitset(v, cap),
-            lteBitset: (v, cap) => numIdx.queryLteBitset(v, cap),
-            betweenBitset: (min, max, cap) => numIdx.queryBetweenBitset(min, max, cap),
-            allDocIdsBitset: (cap) => numIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } 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(),
-            getTrueBitset: (cap) => boolIdx.queryEqBitset(true, cap),
-            getFalseBitset: (cap) => boolIdx.queryEqBitset(false, cap),
-            allDocIdsBitset: (cap) => boolIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } 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(),
-            getDocIdsBitset: (v, cap) => enumIdx.queryEqBitset(v, cap),
-            getDocIdsInBitset: (values, cap) => enumIdx.queryInBitset(values, cap),
-            allDocIdsBitset: (cap) => enumIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } else if (fieldType === "geopoint") {
-      const geoIdx = state.geoIndexes.get(fieldPath);
-      if (geoIdx) {
-        fieldIndexes[fieldPath] = {
-          type: "geopoint",
-          index: geoIdx
-        };
+function indexStringField(state, internalId, fieldPath, text, language, options, fieldLengths, tokensByField) {
+  const fieldTokenList = [];
+  const fieldNameIndex = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
+  const opts = tokenizeOptions(options);
+  const surfaceCounts = /* @__PURE__ */ new Map();
+  if (state.trackPositions) {
+    const tokenFreqs = /* @__PURE__ */ new Map();
+    for (const t of tokenizeIterator(text, language, opts)) {
+      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);
+      countSurface(surfaceCounts, t.surface, t.token);
+    }
+    for (const [token, freq] of tokenFreqs) {
+      state.invertedIdx.insert(token, internalId, freq.count, fieldNameIndex, freq.positions);
+    }
+  } else {
+    const tokenCounts = /* @__PURE__ */ new Map();
+    for (const t of tokenizeIterator(text, language, opts)) {
+      tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
+      fieldTokenList.push(t.token);
+      countSurface(surfaceCounts, t.surface, t.token);
+    }
+    for (const [token, count] of tokenCounts) {
+      state.invertedIdx.insert(token, internalId, count, fieldNameIndex, null);
     }
   }
-  let cachedAllDocIds = null;
-  let cachedAllDocIdsBitset = null;
-  return {
-    fieldIndexes,
-    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
-    get allDocIds() {
-      if (!cachedAllDocIds) {
-        cachedAllDocIds = getAllInternalDocIds(state.docStore);
-      }
-      return cachedAllDocIds;
-    },
-    capacity,
-    get allDocIdsBitset() {
-      if (!cachedAllDocIdsBitset) {
-        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
+  applySurfaceCounts(state, surfaceCounts, 1);
+  fieldLengths[fieldPath] = fieldTokenList.length;
+  tokensByField[fieldPath] = fieldTokenList;
+}
+function indexStringArrayField(state, internalId, fieldPath, arr, language, options, fieldLengths, tokensByField) {
+  const fieldTokenList = [];
+  const fieldNameIndex = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
+  const opts = tokenizeOptions(options);
+  const surfaceCounts = /* @__PURE__ */ new Map();
+  if (state.trackPositions) {
+    const tokenFreqs = /* @__PURE__ */ new Map();
+    let positionOffset = 0;
+    for (const item of arr) {
+      let itemTokenCount = 0;
+      for (const t of tokenizeIterator(item, language, opts)) {
+        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);
+        countSurface(surfaceCounts, t.surface, t.token);
+        itemTokenCount++;
       }
-      return cachedAllDocIdsBitset;
+      positionOffset += itemTokenCount;
     }
-  };
-}
-function applyPartitionFilters(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
-  const resultBitset = evaluateFilters(filters, context);
-  const resolver = state.docStore.resolver();
-  const externalResult = /* @__PURE__ */ new Set();
-  for (let wi = 0; wi < resultBitset.length; wi++) {
-    let word = resultBitset[wi];
-    if (word === 0) continue;
-    const base = wi << 5;
-    while (word !== 0) {
-      const tz = Math.clz32(word & -word) ^ 31;
-      const internalId = base + tz;
-      const externalId = resolver.toExternal(internalId);
-      if (externalId !== void 0) {
-        externalResult.add(externalId);
+    fieldLengths[fieldPath] = fieldTokenList.length;
+    for (const [token, freq] of tokenFreqs) {
+      state.invertedIdx.insert(token, internalId, freq.count, fieldNameIndex, freq.positions);
+    }
+  } else {
+    const tokenCounts = /* @__PURE__ */ new Map();
+    for (const item of arr) {
+      for (const t of tokenizeIterator(item, language, opts)) {
+        tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
+        fieldTokenList.push(t.token);
+        countSurface(surfaceCounts, t.surface, t.token);
       }
-      word &= word - 1;
+    }
+    fieldLengths[fieldPath] = fieldTokenList.length;
+    for (const [token, count] of tokenCounts) {
+      state.invertedIdx.insert(token, internalId, count, fieldNameIndex, null);
     }
   }
-  return externalResult;
-}
-function applyPartitionFiltersBitset(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
-  return evaluateFilters(filters, context);
-}
-
-// 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;
+  applySurfaceCounts(state, surfaceCounts, 1);
+  tokensByField[fieldPath] = fieldTokenList;
 }
-
-// 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;
+function indexDocument(state, docId, document, flatSchema, language, options) {
+  const fieldLengths = {};
+  const tokensByField = {};
+  const internalId = resolveInternalId(state, docId);
+  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, internalId, fieldPath, value, language, options, fieldLengths, tokensByField);
+    } else if (fieldType === "number") {
+      getOrCreateNumericIndex(state, fieldPath).insert(internalId, value);
+    } else if (fieldType === "boolean") {
+      getOrCreateBooleanIndex(state, fieldPath).insert(internalId, value);
+    } else if (fieldType === "enum") {
+      state.enumIndexes.get(fieldPath)?.insert(internalId, value);
+    } else if (fieldType === "geopoint") {
+      const geo = value;
+      state.geoIndexes.get(fieldPath)?.insert(internalId, geo.lat, geo.lon);
+    } else if (fieldType === "string[]") {
+      indexStringArrayField(
+        state,
+        internalId,
+        fieldPath,
+        value,
+        language,
+        options,
+        fieldLengths,
+        tokensByField
+      );
+    } else if (fieldType === "number[]") {
+      const numIdx = getOrCreateNumericIndex(state, fieldPath);
+      for (const num of value) numIdx.insert(internalId, num);
+    } else if (fieldType === "boolean[]") {
+      const boolIdx = getOrCreateBooleanIndex(state, fieldPath);
+      for (const b of value) boolIdx.insert(internalId, b);
+    } else if (fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        for (const e of value) enumIdx.insert(internalId, e);
       }
     }
   }
-  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);
+  return { fieldLengths, tokensByField };
 }
-
-// src/geo/geo-index.ts
-function createGeoIndex() {
-  const entries = [];
-  return {
-    get entries() {
-      return entries;
-    },
-    insert(internalId, lat, lon) {
-      entries.push({ lat, lon, docId: internalId });
-    },
-    remove(internalId) {
-      for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].docId === internalId) {
-          entries.splice(i, 1);
-          return;
-        }
+function removeFromIndexes(state, docId, storedDoc, flatSchema, language, options) {
+  const fieldLengths = {};
+  const tokensByField = {};
+  const fields = storedDoc.fields;
+  const internalId = resolveInternalId(state, docId);
+  const opts = tokenizeOptions(options);
+  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, opts);
+      fieldLengths[fieldPath] = result.tokens.length;
+      const uniqueTokens = /* @__PURE__ */ new Set();
+      const fieldTokenList = [];
+      const surfaceCounts = /* @__PURE__ */ new Map();
+      for (let i = 0; i < result.tokens.length; i++) {
+        const t = result.tokens[i];
+        uniqueTokens.add(t.token);
+        fieldTokenList.push(t.token);
+        countSurface(surfaceCounts, result.surfaces?.[i], t.token);
       }
-    },
-    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);
+      for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
+      applySurfaceCounts(state, surfaceCounts, -1);
+      tokensByField[fieldPath] = fieldTokenList;
+    } else if (fieldType === "number") {
+      state.numericIndexes.get(fieldPath)?.remove(internalId, value);
+    } else if (fieldType === "boolean") {
+      state.booleanIndexes.get(fieldPath)?.remove(internalId, value);
+    } else if (fieldType === "enum") {
+      state.enumIndexes.get(fieldPath)?.remove(internalId, value);
+    } else if (fieldType === "geopoint") {
+      state.geoIndexes.get(fieldPath)?.remove(internalId);
+    } else if (fieldType === "string[]") {
+      const arr = value;
+      const uniqueTokens = /* @__PURE__ */ new Set();
+      const fieldTokenList = [];
+      const surfaceCounts = /* @__PURE__ */ new Map();
+      for (const item of arr) {
+        const result = tokenize(item, language, opts);
+        for (let i = 0; i < result.tokens.length; i++) {
+          const t = result.tokens[i];
+          uniqueTokens.add(t.token);
+          fieldTokenList.push(t.token);
+          countSurface(surfaceCounts, result.surfaces?.[i], t.token);
         }
       }
-      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);
-        }
+      fieldLengths[fieldPath] = fieldTokenList.length;
+      for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
+      applySurfaceCounts(state, surfaceCounts, -1);
+      tokensByField[fieldPath] = fieldTokenList;
+    } else if (fieldType === "number[]") {
+      const numIdx = state.numericIndexes.get(fieldPath);
+      if (numIdx) {
+        for (const num of value) numIdx.remove(internalId, num);
       }
-      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 });
+    } else if (fieldType === "boolean[]") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        for (const b of value) boolIdx.remove(internalId, b);
       }
-    }
-  };
-}
-
-// src/core/field-index/boolean.ts
-function createBooleanIndex() {
-  const trueDocs = /* @__PURE__ */ new Set();
-  const falseDocs = /* @__PURE__ */ new Set();
-  return {
-    insert(internalId, value) {
-      if (value) trueDocs.add(internalId);
-      else falseDocs.add(internalId);
-    },
-    remove(internalId, value) {
-      if (value) trueDocs.delete(internalId);
-      else falseDocs.delete(internalId);
-    },
-    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;
-    },
-    queryEqBitset(value, capacity) {
-      const source = value ? trueDocs : falseDocs;
-      const bs = createBitSet(capacity);
-      for (const id of source) {
-        bitsetSet(bs, id);
+    } else if (fieldType === "enum[]") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        for (const e of value) enumIdx.remove(internalId, e);
       }
-      return bs;
-    },
-    getAllDocIdsBitset(capacity) {
-      const bs = createBitSet(capacity);
-      for (const id of trueDocs) bitsetSet(bs, id);
-      for (const id of falseDocs) bitsetSet(bs, id);
-      return bs;
-    },
-    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);
     }
-  };
+  }
+  return { fieldLengths, tokensByField };
 }
 
-// src/core/field-index/enum.ts
-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;
+// src/core/partition/field-updates.ts
+function resolveInternalId2(state, docId) {
+  const internalId = state.docStore.getInternalId(docId);
+  if (internalId === void 0) {
+    throw new Error(`Internal ID not found for document "${docId}"`);
   }
-  return {
-    insert(internalId, value) {
-      let docSet = valueMap.get(value);
-      if (!docSet) {
-        docSet = /* @__PURE__ */ new Set();
-        valueMap.set(value, docSet);
-      }
-      docSet.add(internalId);
-    },
-    remove(internalId, value) {
-      const docSet = valueMap.get(value);
-      if (!docSet) return;
-      docSet.delete(internalId);
-      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 internalId;
+}
+function updateFieldIndexOnly(state, docId, oldFields, newDoc, flatSchema) {
+  const internalId = resolveInternalId2(state, docId);
+  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(internalId, oldVal);
+        if (newVal !== void 0 && newVal !== null) numIdx.insert(internalId, newVal);
       }
-      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);
-        }
+    } else if (fieldType === "boolean") {
+      const boolIdx = state.booleanIndexes.get(fieldPath);
+      if (boolIdx) {
+        if (oldVal !== void 0 && oldVal !== null) boolIdx.remove(internalId, oldVal);
+        if (newVal !== void 0 && newVal !== null) boolIdx.insert(internalId, newVal);
       }
-      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();
-    },
-    queryEqBitset(value, capacity) {
-      const bs = createBitSet(capacity);
-      const docSet = valueMap.get(value);
-      if (docSet) {
-        for (const id of docSet) bitsetSet(bs, id);
+    } else if (fieldType === "enum") {
+      const enumIdx = state.enumIndexes.get(fieldPath);
+      if (enumIdx) {
+        if (oldVal !== void 0 && oldVal !== null) enumIdx.remove(internalId, oldVal);
+        if (newVal !== void 0 && newVal !== null) enumIdx.insert(internalId, newVal);
       }
-      return bs;
-    },
-    queryInBitset(values, capacity) {
-      const bs = createBitSet(capacity);
-      for (const val of values) {
-        const docSet = valueMap.get(val);
-        if (docSet) {
-          for (const id of docSet) bitsetSet(bs, id);
+    } else if (fieldType === "geopoint") {
+      const geoIdx = state.geoIndexes.get(fieldPath);
+      if (geoIdx) {
+        if (oldVal !== void 0 && oldVal !== null) geoIdx.remove(internalId);
+        if (newVal !== void 0 && newVal !== null) {
+          const geo = newVal;
+          geoIdx.insert(internalId, geo.lat, geo.lon);
         }
       }
-      return bs;
-    },
-    getAllDocIdsBitset(capacity) {
-      const bs = createBitSet(capacity);
-      for (const docSet of valueMap.values()) {
-        for (const id of docSet) bitsetSet(bs, id);
+    } 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(internalId, n);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const n of newVal) numIdx.insert(internalId, n);
+        }
       }
-      return bs;
-    },
-    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);
+    } 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(internalId, b);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const b of newVal) boolIdx.insert(internalId, b);
+        }
       }
-      return result;
-    },
-    deserialize(data) {
-      valueMap.clear();
-      for (const value of Object.keys(data)) {
-        valueMap.set(value, new Set(data[value]));
+    } 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(internalId, e);
+        }
+        if (newVal !== void 0 && newVal !== null) {
+          for (const e of newVal) enumIdx.insert(internalId, e);
+        }
       }
     }
-  };
+  }
 }
 
-// src/core/field-index/numeric.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;
+// src/filters/combinators.ts
+function applyAndBitset(bitsets) {
+  if (bitsets.length === 0) return new Uint32Array(0);
+  if (bitsets.length === 1) return bitsets[0];
+  let result = bitsets[0];
+  for (let i = 1; i < bitsets.length; i++) {
+    result = bitsetAnd(result, bitsets[i]);
   }
-  return lo;
+  return result;
 }
-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;
+function applyOrBitset(bitsets) {
+  if (bitsets.length === 0) return new Uint32Array(0);
+  if (bitsets.length === 1) return bitsets[0];
+  let result = bitsets[0];
+  for (let i = 1; i < bitsets.length; i++) {
+    result = bitsetOr(result, bitsets[i]);
   }
-  return lo;
+  return result;
 }
-function collectDocIds(entries, from, to) {
-  const result = /* @__PURE__ */ new Set();
-  for (let i = from; i < to; i++) {
-    result.add(entries[i].docId);
+function applyNotBitset(excluded, capacity) {
+  return bitsetNot(excluded, capacity);
+}
+
+// src/filters/operators/shared.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 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/operators/bitset.ts
+function resolveBitset(bs) {
+  return typeof bs === "function" ? bs() : bs;
+}
+function scanToBitset(docIds, capacity, getValue, predicate) {
+  const resolved = resolveBitset(docIds);
+  const result = createBitSet(capacity);
+  for (let wi = 0; wi < resolved.length; wi++) {
+    let word = resolved[wi];
+    if (word === 0) continue;
+    const base = wi << 5;
+    while (word !== 0) {
+      const tz = Math.clz32(word & -word) ^ 31;
+      const id = base + tz;
+      if (predicate(getValue(id))) {
+        bitsetSet(result, id);
+      }
+      word &= word - 1;
+    }
   }
   return result;
 }
-function collectDocIdsBitset(entries, from, to, capacity) {
-  const bs = createBitSet(capacity);
-  for (let i = from; i < to; i++) {
-    bitsetSet(bs, entries[i].docId);
+function applyEqBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric" && typeof value === "number") {
+    return fieldIndex.index.eqBitset(value, capacity);
   }
-  return bs;
+  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
+    return value ? fieldIndex.index.getTrueBitset(capacity) : fieldIndex.index.getFalseBitset(capacity);
+  }
+  if (fieldIndex?.type === "enum" && typeof value === "string") {
+    return fieldIndex.index.getDocIdsBitset(value, capacity);
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === value);
 }
-function createNumericIndex() {
-  let entries = [];
-  let sorted = true;
-  function ensureSorted() {
-    if (!sorted) {
-      entries.sort((a, b) => a.value - b.value);
-      sorted = true;
-    }
+function applyNeBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric" && typeof value === "number") {
+    const all = fieldIndex.index.allDocIdsBitset(capacity);
+    const eq = fieldIndex.index.eqBitset(value, capacity);
+    return bitsetAnd(all, bitsetNot(eq, capacity));
   }
-  return {
-    insert(internalId, value) {
-      entries.push({ value, docId: internalId });
-      sorted = false;
-    },
-    remove(internalId, value) {
-      ensureSorted();
-      const start = lowerBound(entries, value);
-      const end = upperBound(entries, value);
-      for (let i = start; i < end; i++) {
-        if (entries[i].docId === internalId) {
-          entries.splice(i, 1);
-          return;
-        }
-      }
-    },
-    queryEq(value) {
-      ensureSorted();
-      return collectDocIds(entries, lowerBound(entries, value), upperBound(entries, value));
-    },
-    queryNe(value) {
-      ensureSorted();
-      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) {
-      ensureSorted();
-      return collectDocIds(entries, upperBound(entries, value), entries.length);
-    },
-    queryGte(value) {
-      ensureSorted();
-      return collectDocIds(entries, lowerBound(entries, value), entries.length);
-    },
-    queryLt(value) {
-      ensureSorted();
-      return collectDocIds(entries, 0, lowerBound(entries, value));
-    },
-    queryLte(value) {
-      ensureSorted();
-      return collectDocIds(entries, 0, upperBound(entries, value));
-    },
-    queryBetween(min, max) {
-      ensureSorted();
-      return collectDocIds(entries, lowerBound(entries, min), upperBound(entries, max));
-    },
-    getAllDocIds() {
-      return collectDocIds(entries, 0, entries.length);
-    },
-    queryEqBitset(value, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, lowerBound(entries, value), upperBound(entries, value), capacity);
-    },
-    queryGtBitset(value, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, upperBound(entries, value), entries.length, capacity);
-    },
-    queryGteBitset(value, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, lowerBound(entries, value), entries.length, capacity);
-    },
-    queryLtBitset(value, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, 0, lowerBound(entries, value), capacity);
-    },
-    queryLteBitset(value, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, 0, upperBound(entries, value), capacity);
-    },
-    queryBetweenBitset(min, max, capacity) {
-      ensureSorted();
-      return collectDocIdsBitset(entries, lowerBound(entries, min), upperBound(entries, max), capacity);
-    },
-    getAllDocIdsBitset(capacity) {
-      return collectDocIdsBitset(entries, 0, entries.length, capacity);
-    },
-    count() {
-      return entries.length;
-    },
-    clear() {
-      entries = [];
-      sorted = true;
-    },
-    serialize() {
-      ensureSorted();
-      return entries.slice();
-    },
-    deserialize(data) {
-      entries = data.slice();
-      sorted = true;
-    }
-  };
+  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
+    return value ? fieldIndex.index.getFalseBitset(capacity) : fieldIndex.index.getTrueBitset(capacity);
+  }
+  if (fieldIndex?.type === "enum" && typeof value === "string") {
+    const all = fieldIndex.index.allDocIdsBitset(capacity);
+    const eq = fieldIndex.index.getDocIdsBitset(value, capacity);
+    return bitsetAnd(all, bitsetNot(eq, capacity));
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null && v !== value);
 }
-
-// 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());
+function applyGtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.gtBitset(value, capacity);
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v > value);
+}
+function applyLtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.ltBitset(value, capacity);
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v < value);
+}
+function applyGteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.gteBitset(value, capacity);
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= value);
+}
+function applyLteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.lteBitset(value, capacity);
+  }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v <= value);
+}
+function applyBetweenBitset(range, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "numeric") {
+    return fieldIndex.index.betweenBitset(range[0], range[1], capacity);
   }
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= range[0] && v <= range[1]);
 }
-function getOrCreateNumericIndex(state, fieldPath) {
-  let idx = state.numericIndexes.get(fieldPath);
-  if (!idx) {
-    idx = createNumericIndex();
-    state.numericIndexes.set(fieldPath, idx);
+function applyInBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "enum") {
+    return fieldIndex.index.getDocIdsInBitset(values, capacity);
   }
-  return idx;
+  const valSet = new Set(values);
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && valSet.has(v));
 }
-function getOrCreateBooleanIndex(state, fieldPath) {
-  let idx = state.booleanIndexes.get(fieldPath);
-  if (!idx) {
-    idx = createBooleanIndex();
-    state.booleanIndexes.set(fieldPath, idx);
+function applyNinBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
+  if (fieldIndex?.type === "enum") {
+    const all = fieldIndex.index.allDocIdsBitset(capacity);
+    const matched = fieldIndex.index.getDocIdsInBitset(values, capacity);
+    return bitsetAnd(all, bitsetNot(matched, capacity));
   }
-  return idx;
+  const valSet = new Set(values);
+  return scanToBitset(
+    allDocsBitset,
+    capacity,
+    getValue,
+    (v) => v !== void 0 && v !== null && typeof v === "string" && !valSet.has(v)
+  );
 }
-function resolveInternalId(state, docId) {
-  const internalId = state.docStore.getInternalId(docId);
-  if (internalId === void 0) {
-    throw new Error(`Internal ID not found for document "${docId}"`);
-  }
-  return internalId;
+function applyStartsWithBitset(prefix, allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.startsWith(prefix));
 }
-function indexStringField(state, internalId, fieldPath, text, language, options, fieldLengths, tokensByField) {
-  const fieldTokenList = [];
-  const fieldNameIndex = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
-  const opts = tokenizeOptions(options);
-  if (state.trackPositions) {
-    const tokenFreqs = /* @__PURE__ */ new Map();
-    for (const t of tokenizeIterator(text, language, opts)) {
-      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, internalId, freq.count, fieldNameIndex, freq.positions);
+function applyEndsWithBitset(suffix, allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.endsWith(suffix));
+}
+function applyContainsAllBitset(values, allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
+    if (!Array.isArray(v)) return false;
+    const arr = v;
+    for (const val of values) {
+      if (!arr.includes(val)) return false;
     }
-  } else {
-    const tokenCounts = /* @__PURE__ */ new Map();
-    for (const t of tokenizeIterator(text, language, opts)) {
-      tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
-      fieldTokenList.push(t.token);
+    return true;
+  });
+}
+function applyMatchesAnyBitset(values, allDocsBitset, capacity, getValue) {
+  const valSet = new Set(values);
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
+    if (!Array.isArray(v)) return false;
+    for (const item of v) {
+      if (valSet.has(item)) return true;
     }
-    for (const [token, count] of tokenCounts) {
-      state.invertedIdx.insert(token, internalId, count, fieldNameIndex, null);
+    return false;
+  });
+}
+function applySizeBitset(sizeFilter, allDocsBitset, capacity, getValue) {
+  return scanToBitset(
+    allDocsBitset,
+    capacity,
+    getValue,
+    (v) => Array.isArray(v) && matchesNumericComparison(v.length, sizeFilter)
+  );
+}
+function applyExistsBitset(allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null);
+}
+function applyNotExistsBitset(allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === void 0 || v === null);
+}
+function applyIsEmptyBitset(allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
+    if (v === void 0 || v === null) return true;
+    if (typeof v === "string" && v === "") return true;
+    if (Array.isArray(v) && v.length === 0) return true;
+    return false;
+  });
+}
+function applyIsNotEmptyBitset(allDocsBitset, capacity, getValue) {
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
+    if (v === void 0 || v === null) return false;
+    if (typeof v === "string" && v === "") return false;
+    if (Array.isArray(v) && v.length === 0) return false;
+    return true;
+  });
+}
+function applyGeoRadiusBitset(filter, geoIndex, capacity) {
+  const distanceMeters = convertToMeters(filter.distance, filter.unit);
+  const setResult = geoIndex.radiusQuery(
+    filter.lat,
+    filter.lon,
+    distanceMeters,
+    filter.inside ?? true,
+    filter.highPrecision ?? false
+  );
+  return bitsetFromSet(setResult, capacity);
+}
+function applyGeoPolygonBitset(filter, geoIndex, capacity) {
+  const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
+  return bitsetFromSet(setResult, capacity);
+}
+
+// src/filters/evaluator.ts
+function evaluateFilters(expression, context) {
+  const bitsets = [];
+  if (expression.fields) {
+    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
+      bitsets.push(evaluateFieldFilter(fieldPath, filter, context));
     }
   }
-  fieldLengths[fieldPath] = fieldTokenList.length;
-  tokensByField[fieldPath] = fieldTokenList;
+  if (expression.and?.length) {
+    const andBitsets = expression.and.map((expr) => evaluateFilters(expr, context));
+    bitsets.push(applyAndBitset(andBitsets));
+  }
+  if (expression.or?.length) {
+    const orBitsets = expression.or.map((expr) => evaluateFilters(expr, context));
+    bitsets.push(applyOrBitset(orBitsets));
+  }
+  if (expression.not) {
+    const excluded = evaluateFilters(expression.not, context);
+    const universe = context.allDocIdsBitset;
+    bitsets.push(applyAndBitset([universe, applyNotBitset(excluded, context.capacity)]));
+  }
+  if (bitsets.length === 0) return context.allDocIdsBitset;
+  if (bitsets.length === 1) return bitsets[0];
+  return applyAndBitset(bitsets);
 }
-function indexStringArrayField(state, internalId, fieldPath, arr, language, options, fieldLengths, tokensByField) {
-  const fieldTokenList = [];
-  const fieldNameIndex = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
-  const opts = tokenizeOptions(options);
-  if (state.trackPositions) {
-    const tokenFreqs = /* @__PURE__ */ new Map();
-    let positionOffset = 0;
-    for (const item of arr) {
-      let itemTokenCount = 0;
-      for (const t of tokenizeIterator(item, language, opts)) {
-        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);
-        itemTokenCount++;
-      }
-      positionOffset += itemTokenCount;
-    }
-    fieldLengths[fieldPath] = fieldTokenList.length;
-    for (const [token, freq] of tokenFreqs) {
-      state.invertedIdx.insert(token, internalId, freq.count, fieldNameIndex, freq.positions);
-    }
-  } else {
-    const tokenCounts = /* @__PURE__ */ new Map();
-    for (const item of arr) {
-      for (const t of tokenizeIterator(item, language, opts)) {
-        tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
-        fieldTokenList.push(t.token);
-      }
-    }
-    fieldLengths[fieldPath] = fieldTokenList.length;
-    for (const [token, count] of tokenCounts) {
-      state.invertedIdx.insert(token, internalId, count, fieldNameIndex, null);
+function evaluateFieldFilter(fieldPath, filter, context) {
+  const fieldIndex = context.fieldIndexes[fieldPath];
+  const getValue = (internalId) => context.getFieldValue(internalId, fieldPath);
+  const f = filter;
+  const bitsets = [];
+  const { capacity } = context;
+  let allDocsBitset = null;
+  const getAllDocsBitset = () => {
+    if (allDocsBitset === null) {
+      allDocsBitset = context.allDocIdsBitset;
     }
+    return allDocsBitset;
+  };
+  if ("radius" in f && f.radius) {
+    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
+    bitsets.push(applyGeoRadiusBitset(filter.radius, geoIndex, capacity));
+  }
+  if ("polygon" in f && f.polygon) {
+    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
+    bitsets.push(applyGeoPolygonBitset(filter.polygon, geoIndex, capacity));
+  }
+  if ("eq" in f && f.eq !== void 0) {
+    bitsets.push(applyEqBitset(f.eq, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("ne" in f && f.ne !== void 0) {
+    bitsets.push(applyNeBitset(f.ne, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("gt" in f && f.gt !== void 0) {
+    bitsets.push(applyGtBitset(f.gt, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("lt" in f && f.lt !== void 0) {
+    bitsets.push(applyLtBitset(f.lt, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("gte" in f && f.gte !== void 0) {
+    bitsets.push(applyGteBitset(f.gte, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("lte" in f && f.lte !== void 0) {
+    bitsets.push(applyLteBitset(f.lte, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("between" in f && f.between !== void 0) {
+    bitsets.push(applyBetweenBitset(f.between, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("in" in f && f.in !== void 0) {
+    bitsets.push(applyInBitset(f.in, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("nin" in f && f.nin !== void 0) {
+    bitsets.push(applyNinBitset(f.nin, getAllDocsBitset, capacity, getValue, fieldIndex));
+  }
+  if ("startsWith" in f && f.startsWith !== void 0) {
+    bitsets.push(applyStartsWithBitset(f.startsWith, getAllDocsBitset, capacity, getValue));
+  }
+  if ("endsWith" in f && f.endsWith !== void 0) {
+    bitsets.push(applyEndsWithBitset(f.endsWith, getAllDocsBitset, capacity, getValue));
+  }
+  if ("containsAll" in f && f.containsAll !== void 0) {
+    bitsets.push(
+      applyContainsAllBitset(f.containsAll, getAllDocsBitset, capacity, getValue)
+    );
+  }
+  if ("matchesAny" in f && f.matchesAny !== void 0) {
+    bitsets.push(
+      applyMatchesAnyBitset(f.matchesAny, getAllDocsBitset, capacity, getValue)
+    );
+  }
+  if ("size" in f && f.size !== void 0) {
+    bitsets.push(applySizeBitset(f.size, getAllDocsBitset, capacity, getValue));
   }
-  tokensByField[fieldPath] = fieldTokenList;
-}
-function indexDocument(state, docId, document, flatSchema, language, options) {
-  const fieldLengths = {};
-  const tokensByField = {};
-  const internalId = resolveInternalId(state, docId);
-  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, internalId, fieldPath, value, language, options, fieldLengths, tokensByField);
-    } else if (fieldType === "number") {
-      getOrCreateNumericIndex(state, fieldPath).insert(internalId, value);
-    } else if (fieldType === "boolean") {
-      getOrCreateBooleanIndex(state, fieldPath).insert(internalId, value);
-    } else if (fieldType === "enum") {
-      state.enumIndexes.get(fieldPath)?.insert(internalId, value);
-    } else if (fieldType === "geopoint") {
-      const geo = value;
-      state.geoIndexes.get(fieldPath)?.insert(internalId, geo.lat, geo.lon);
-    } else if (fieldType === "string[]") {
-      indexStringArrayField(
-        state,
-        internalId,
-        fieldPath,
-        value,
-        language,
-        options,
-        fieldLengths,
-        tokensByField
-      );
-    } else if (fieldType === "number[]") {
-      const numIdx = getOrCreateNumericIndex(state, fieldPath);
-      for (const num of value) numIdx.insert(internalId, num);
-    } else if (fieldType === "boolean[]") {
-      const boolIdx = getOrCreateBooleanIndex(state, fieldPath);
-      for (const b of value) boolIdx.insert(internalId, b);
-    } else if (fieldType === "enum[]") {
-      const enumIdx = state.enumIndexes.get(fieldPath);
-      if (enumIdx) {
-        for (const e of value) enumIdx.insert(internalId, e);
-      }
-    }
+  if ("exists" in f && f.exists !== void 0) {
+    bitsets.push(
+      f.exists ? applyExistsBitset(getAllDocsBitset, capacity, getValue) : applyNotExistsBitset(getAllDocsBitset, capacity, getValue)
+    );
   }
-  return { fieldLengths, tokensByField };
+  if ("notExists" in f && f.notExists !== void 0) {
+    bitsets.push(
+      f.notExists ? applyNotExistsBitset(getAllDocsBitset, capacity, getValue) : applyExistsBitset(getAllDocsBitset, capacity, getValue)
+    );
+  }
+  if ("isEmpty" in f && f.isEmpty !== void 0) {
+    bitsets.push(
+      f.isEmpty ? applyIsEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue)
+    );
+  }
+  if ("isNotEmpty" in f && f.isNotEmpty !== void 0) {
+    bitsets.push(
+      f.isNotEmpty ? applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsEmptyBitset(getAllDocsBitset, capacity, getValue)
+    );
+  }
+  if (bitsets.length === 0) return context.allDocIdsBitset;
+  if (bitsets.length === 1) return bitsets[0];
+  return applyAndBitset(bitsets);
 }
-function removeFromIndexes(state, docId, storedDoc, flatSchema, language, options) {
-  const fieldLengths = {};
-  const tokensByField = {};
-  const fields = storedDoc.fields;
-  const internalId = resolveInternalId(state, docId);
-  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, internalId);
-      tokensByField[fieldPath] = fieldTokenList;
-    } else if (fieldType === "number") {
-      state.numericIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "boolean") {
-      state.booleanIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "enum") {
-      state.enumIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "geopoint") {
-      state.geoIndexes.get(fieldPath)?.remove(internalId);
-    } 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, internalId);
-      tokensByField[fieldPath] = fieldTokenList;
-    } else if (fieldType === "number[]") {
-      const numIdx = state.numericIndexes.get(fieldPath);
-      if (numIdx) {
-        for (const num of value) numIdx.remove(internalId, num);
-      }
-    } else if (fieldType === "boolean[]") {
-      const boolIdx = state.booleanIndexes.get(fieldPath);
-      if (boolIdx) {
-        for (const b of value) boolIdx.remove(internalId, b);
-      }
-    } else if (fieldType === "enum[]") {
-      const enumIdx = state.enumIndexes.get(fieldPath);
-      if (enumIdx) {
-        for (const e of value) enumIdx.remove(internalId, e);
-      }
-    }
+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 { fieldLengths, tokensByField };
+  return fieldIndex.index;
 }
-function updateFieldIndexOnly(state, docId, oldFields, newDoc, flatSchema) {
-  const internalId = resolveInternalId(state, docId);
-  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") {
+
+// src/core/partition/filters.ts
+function buildFilterContext(state, schema) {
+  const flat = getFlatSchema(state, schema);
+  const fieldIndexes = {};
+  const capacity = state.docStore.internalIdCapacity();
+  for (const [fieldPath, fieldType] of Object.entries(flat)) {
+    if (fieldType === "number" || fieldType === "number[]") {
       const numIdx = state.numericIndexes.get(fieldPath);
       if (numIdx) {
-        if (oldVal !== void 0 && oldVal !== null) numIdx.remove(internalId, oldVal);
-        if (newVal !== void 0 && newVal !== null) numIdx.insert(internalId, newVal);
+        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(),
+            eqBitset: (v, cap) => numIdx.queryEqBitset(v, cap),
+            gtBitset: (v, cap) => numIdx.queryGtBitset(v, cap),
+            gteBitset: (v, cap) => numIdx.queryGteBitset(v, cap),
+            ltBitset: (v, cap) => numIdx.queryLtBitset(v, cap),
+            lteBitset: (v, cap) => numIdx.queryLteBitset(v, cap),
+            betweenBitset: (min, max, cap) => numIdx.queryBetweenBitset(min, max, cap),
+            allDocIdsBitset: (cap) => numIdx.getAllDocIdsBitset(cap)
+          }
+        };
       }
-    } else if (fieldType === "boolean") {
+    } else if (fieldType === "boolean" || fieldType === "boolean[]") {
       const boolIdx = state.booleanIndexes.get(fieldPath);
       if (boolIdx) {
-        if (oldVal !== void 0 && oldVal !== null) boolIdx.remove(internalId, oldVal);
-        if (newVal !== void 0 && newVal !== null) boolIdx.insert(internalId, newVal);
+        fieldIndexes[fieldPath] = {
+          type: "boolean",
+          index: {
+            getTrue: () => boolIdx.queryEq(true),
+            getFalse: () => boolIdx.queryEq(false),
+            allDocIds: () => boolIdx.getAllDocIds(),
+            getTrueBitset: (cap) => boolIdx.queryEqBitset(true, cap),
+            getFalseBitset: (cap) => boolIdx.queryEqBitset(false, cap),
+            allDocIdsBitset: (cap) => boolIdx.getAllDocIdsBitset(cap)
+          }
+        };
       }
-    } else if (fieldType === "enum") {
+    } else if (fieldType === "enum" || fieldType === "enum[]") {
       const enumIdx = state.enumIndexes.get(fieldPath);
       if (enumIdx) {
-        if (oldVal !== void 0 && oldVal !== null) enumIdx.remove(internalId, oldVal);
-        if (newVal !== void 0 && newVal !== null) enumIdx.insert(internalId, newVal);
+        fieldIndexes[fieldPath] = {
+          type: "enum",
+          index: {
+            getDocIds: (v) => enumIdx.queryEq(v),
+            allDocIds: () => enumIdx.getAllDocIds(),
+            getDocIdsBitset: (v, cap) => enumIdx.queryEqBitset(v, cap),
+            getDocIdsInBitset: (values, cap) => enumIdx.queryInBitset(values, cap),
+            allDocIdsBitset: (cap) => enumIdx.getAllDocIdsBitset(cap)
+          }
+        };
       }
     } else if (fieldType === "geopoint") {
       const geoIdx = state.geoIndexes.get(fieldPath);
       if (geoIdx) {
-        if (oldVal !== void 0 && oldVal !== null) geoIdx.remove(internalId);
-        if (newVal !== void 0 && newVal !== null) {
-          const geo = newVal;
-          geoIdx.insert(internalId, geo.lat, geo.lon);
-        }
+        fieldIndexes[fieldPath] = {
+          type: "geopoint",
+          index: geoIdx
+        };
       }
-    } 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(internalId, n);
-        }
-        if (newVal !== void 0 && newVal !== null) {
-          for (const n of newVal) numIdx.insert(internalId, n);
-        }
+    }
+  }
+  let cachedAllDocIds = null;
+  let cachedAllDocIdsBitset = null;
+  return {
+    fieldIndexes,
+    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
+    get allDocIds() {
+      if (!cachedAllDocIds) {
+        cachedAllDocIds = getAllInternalDocIds(state.docStore);
       }
-    } 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(internalId, b);
-        }
-        if (newVal !== void 0 && newVal !== null) {
-          for (const b of newVal) boolIdx.insert(internalId, b);
-        }
+      return cachedAllDocIds;
+    },
+    capacity,
+    get allDocIdsBitset() {
+      if (!cachedAllDocIdsBitset) {
+        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
       }
-    } 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(internalId, e);
-        }
-        if (newVal !== void 0 && newVal !== null) {
-          for (const e of newVal) enumIdx.insert(internalId, e);
-        }
+      return cachedAllDocIdsBitset;
+    }
+  };
+}
+function applyPartitionFilters(state, filters, schema) {
+  const context = buildFilterContext(state, schema);
+  const resultBitset = evaluateFilters(filters, context);
+  const resolver = state.docStore.resolver();
+  const externalResult = /* @__PURE__ */ new Set();
+  for (let wi = 0; wi < resultBitset.length; wi++) {
+    let word = resultBitset[wi];
+    if (word === 0) continue;
+    const base = wi << 5;
+    while (word !== 0) {
+      const tz = Math.clz32(word & -word) ^ 31;
+      const internalId = base + tz;
+      const externalId = resolver.toExternal(internalId);
+      if (externalId !== void 0) {
+        externalResult.add(externalId);
       }
+      word &= word - 1;
     }
   }
+  return externalResult;
+}
+function applyPartitionFiltersBitset(state, filters, schema) {
+  const context = buildFilterContext(state, schema);
+  return evaluateFilters(filters, context);
 }
 
 // src/core/scorer.ts
@@ -3200,6 +3558,7 @@ function accumulateTermScore(docScores, internalId, termScore, collect, fieldNam
 function searchFulltext(state, params) {
   const {
     queryTokens,
+    prefixExpansion,
     fields,
     boost,
     tolerance = 0,
@@ -3224,9 +3583,132 @@ function searchFulltext(state, params) {
   const useIntersection = termMatch === "all" && queryTokens.length > 1;
   const fieldNames = state.fieldNameTable.names;
   const resolver = state.docStore.resolver();
+  function resolveFieldLength(internalId, fieldName, avgLen) {
+    let cachedLengths = fieldLengthCache.get(internalId);
+    if (cachedLengths === void 0) {
+      const externalId = resolver.toExternal(internalId);
+      const storedDoc = externalId !== void 0 ? state.docStore.get(externalId) : void 0;
+      cachedLengths = storedDoc?.fieldLengths ?? null;
+      fieldLengthCache.set(internalId, cachedLengths);
+    }
+    return cachedLengths?.[fieldName] ?? avgLen;
+  }
+  function resolvePrefixMatches(token, expansionTerms) {
+    const found = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const term of [token, ...expansionTerms]) {
+      if (seen.has(term)) continue;
+      seen.add(term);
+      const postingList = state.invertedIdx.lookup(term);
+      if (!postingList) continue;
+      const docFreq = globalStats ? globalDocFreqs[term] ?? postingList.docIdSet.size : postingList.docIdSet.size;
+      found.push({ token: term, postingList, docFreq });
+    }
+    if (found.length === 0) return [];
+    let blendedDf = 0;
+    for (const f of found) {
+      if (f.docFreq > blendedDf) blendedDf = f.docFreq;
+    }
+    const blendedIdf = computeIDF(blendedDf, totalDocs);
+    return found.map((f) => ({
+      token: f.token,
+      factor: Math.min(1, token.length / f.token.length),
+      postingList: f.postingList,
+      docFreq: blendedDf,
+      idf: blendedIdf
+    }));
+  }
+  function computePrefixContributions(matches, collect) {
+    const best = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      const perTerm = /* @__PURE__ */ new Map();
+      const list = match.postingList;
+      const hasDeleted = list.deletedDocs.size > 0;
+      for (let pi = 0; pi < list.length; pi++) {
+        const internalId = list.docIds[pi];
+        if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+        if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
+        const fieldName = fieldNames[list.fieldNameIndices[pi]];
+        if (fields && !fields.includes(fieldName)) continue;
+        const termFrequency = list.termFrequencies[pi];
+        const fieldBoost = boost?.[fieldName] ?? 1;
+        const avgLen = avgFieldLengths[fieldName] ?? 1;
+        const actualFieldLength = resolveFieldLength(internalId, fieldName, avgLen);
+        const termScore = scoreFn(termFrequency, match.docFreq, totalDocs, actualFieldLength, avgLen, bm25Params) * fieldBoost * match.factor;
+        const existing = perTerm.get(internalId);
+        if (existing) {
+          existing.score += termScore;
+          if (collect) {
+            existing.termFrequencies[`${fieldName}:${match.token}`] = termFrequency;
+            existing.fieldLengths[fieldName] = actualFieldLength;
+          }
+        } else if (collect) {
+          perTerm.set(internalId, {
+            score: termScore,
+            token: match.token,
+            idf: match.idf,
+            termFrequencies: { [`${fieldName}:${match.token}`]: termFrequency },
+            fieldLengths: { [fieldName]: actualFieldLength }
+          });
+        } else {
+          perTerm.set(internalId, {
+            score: termScore,
+            token: match.token,
+            idf: match.idf,
+            termFrequencies: EMPTY_COMPONENTS,
+            fieldLengths: EMPTY_COMPONENTS
+          });
+        }
+      }
+      for (const [internalId, contribution] of perTerm) {
+        const current = best.get(internalId);
+        if (!current || contribution.score > current.score) {
+          best.set(internalId, contribution);
+        }
+      }
+    }
+    return best;
+  }
+  function mergePrefixContribution(internalId, contribution, collect) {
+    const existing = docScores.get(internalId);
+    if (existing) {
+      existing.score += contribution.score;
+      if (collect) {
+        Object.assign(existing.termFrequencies, contribution.termFrequencies);
+        Object.assign(existing.fieldLengths, contribution.fieldLengths);
+        existing.idf[contribution.token] = contribution.idf;
+      }
+      return;
+    }
+    if (collect) {
+      docScores.set(internalId, {
+        score: contribution.score,
+        termFrequencies: contribution.termFrequencies,
+        fieldLengths: contribution.fieldLengths,
+        idf: { [contribution.token]: contribution.idf }
+      });
+    } else {
+      docScores.set(internalId, {
+        score: contribution.score,
+        termFrequencies: EMPTY_COMPONENTS,
+        fieldLengths: EMPTY_COMPONENTS,
+        idf: EMPTY_COMPONENTS
+      });
+    }
+  }
   if (useIntersection) {
     const resolved = [];
+    let prefixMatches = [];
     for (const qt of queryTokens) {
+      if (prefixExpansion && qt.token === prefixExpansion.token) {
+        prefixMatches = resolvePrefixMatches(qt.token, prefixExpansion.terms);
+        let totalPostings2 = 0;
+        for (const m of prefixMatches) {
+          totalPostings2 += m.postingList.length;
+        }
+        resolved.push({ token: qt.token, matches: [], totalPostings: totalPostings2, isPrefix: true });
+        continue;
+      }
       const rawMatches = exact ? (() => {
         const postingList = state.invertedIdx.lookup(qt.token);
         return postingList ? [{ token: qt.token, postingList }] : [];
@@ -3243,6 +3725,14 @@ function searchFulltext(state, params) {
     }
     resolved.sort((a, b) => a.totalPostings - b.totalPostings);
     for (let tokenIndex = 0; tokenIndex < resolved.length; tokenIndex++) {
+      if (resolved[tokenIndex].isPrefix) {
+        const contributions = computePrefixContributions(prefixMatches, collectComponents);
+        for (const [internalId, contribution] of contributions) {
+          if (tokenIndex > 0 && !docScores.has(internalId)) continue;
+          mergePrefixContribution(internalId, contribution, collectComponents);
+        }
+        continue;
+      }
       for (const match of resolved[tokenIndex].matches) {
         const list = match.postingList;
         const hasDeleted = list.deletedDocs.size > 0;
@@ -3282,6 +3772,16 @@ function searchFulltext(state, params) {
     }
   } else {
     for (const qt of queryTokens) {
+      if (prefixExpansion && qt.token === prefixExpansion.token) {
+        const contributions = computePrefixContributions(
+          resolvePrefixMatches(qt.token, prefixExpansion.terms),
+          collectComponents
+        );
+        for (const [internalId, contribution] of contributions) {
+          mergePrefixContribution(internalId, contribution, collectComponents);
+        }
+        continue;
+      }
       const matchingPostings = exact ? (() => {
         const postingList = state.invertedIdx.lookup(qt.token);
         return postingList ? [{ token: qt.token, postingList }] : [];
@@ -3468,6 +3968,7 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
       enum: serializedEnum,
       geopoint: serializedGeo
     },
+    surfaceForms: state.surfaceRegistry.serialize(),
     statistics: serializedStats
   };
 }
@@ -3527,6 +4028,7 @@ function deserializePartition(state, data, clearFn, schema) {
     geoIdx.deserialize(converted);
     state.geoIndexes.set(path, geoIdx);
   }
+  state.surfaceRegistry.deserialize(data.surfaceForms ?? {});
   state.stats.deserialize(data.statistics);
   const flatSchema = getFlatSchema(state, schema);
   const serializedFields = data.schema;
@@ -3544,6 +4046,72 @@ function deserializePartition(state, data, clearFn, schema) {
   }
 }
 
+// src/core/partition/suggestions.ts
+function verbatimOccurrences(state, token) {
+  const postingList = state.invertedIdx.lookup(token);
+  if (!postingList) return 0;
+  const derived = postingList.totalTermFrequency - state.surfaceRegistry.stemChangedTotalFor(token);
+  return derived > 0 ? derived : 0;
+}
+function suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit) {
+  if (limit <= 0 || surfacePrefix.length === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
+    const postingList = state.invertedIdx.lookup(candidate.token);
+    if (!postingList || postingList.docIdSet.size === 0) continue;
+    let group = groups.get(candidate.token);
+    if (!group) {
+      group = { documentFrequency: postingList.docIdSet.size, surfaces: [] };
+      groups.set(candidate.token, group);
+    }
+    group.surfaces.push({ surface: candidate.surface, occurrences: candidate.occurrences });
+  }
+  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedPrefix !== surfacePrefix && stemmedPrefix.length > 0 ? [surfacePrefix, stemmedPrefix] : [surfacePrefix];
+  for (const prefix of termPrefixes) {
+    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
+      const occurrences = verbatimOccurrences(state, suggestion.term);
+      if (occurrences === 0) continue;
+      let group = groups.get(suggestion.term);
+      if (!group) {
+        group = { documentFrequency: suggestion.documentFrequency, surfaces: [] };
+        groups.set(suggestion.term, group);
+      } else if (group.surfaces.some((s) => s.surface === suggestion.term)) {
+        continue;
+      }
+      group.surfaces.push({ surface: suggestion.term, occurrences });
+    }
+  }
+  const results = [];
+  for (const [token, group] of groups) {
+    results.push({ token, documentFrequency: group.documentFrequency, surfaces: group.surfaces });
+  }
+  results.sort((a, b) => b.documentFrequency - a.documentFrequency || (a.token < b.token ? -1 : 1));
+  if (results.length > limit) results.length = limit;
+  return results;
+}
+function expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions) {
+  if (maxExpansions <= 0 || surfacePrefix.length === 0) return [];
+  const dfByToken = /* @__PURE__ */ new Map();
+  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
+    if (dfByToken.has(candidate.token)) continue;
+    const postingList = state.invertedIdx.lookup(candidate.token);
+    if (!postingList || postingList.docIdSet.size === 0) continue;
+    dfByToken.set(candidate.token, postingList.docIdSet.size);
+  }
+  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedToken !== surfacePrefix && stemmedToken.length > 0 ? [surfacePrefix, stemmedToken] : [surfacePrefix];
+  for (const prefix of termPrefixes) {
+    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
+      if (dfByToken.has(suggestion.term)) continue;
+      if (verbatimOccurrences(state, suggestion.term) === 0) continue;
+      dfByToken.set(suggestion.term, suggestion.documentFrequency);
+    }
+  }
+  const entries = Array.from(dfByToken.entries());
+  entries.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+  if (entries.length > maxExpansions) entries.length = maxExpansions;
+  return entries.map((e) => e[0]);
+}
+
 // src/core/partition/wire-payload.ts
 function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalPartitions, language, schema) {
   const flatSchema = getFlatSchema(state, schema);
@@ -3640,6 +4208,7 @@ function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalP
       enum: wireEnum,
       geopoint: wireGeo
     },
+    surface_forms: state.surfaceRegistry.serialize(),
     statistics: {
       total_documents: serializedStats.totalDocuments,
       total_field_lengths: serializedStats.totalFieldLengths,
@@ -3656,6 +4225,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     invertedIdx: createInvertedIndex(fieldNameTable),
     docStore: createDocumentStore(),
     stats: createPartitionStats(),
+    surfaceRegistry: createSurfaceRegistry(),
     numericIndexes: /* @__PURE__ */ new Map(),
     booleanIndexes: /* @__PURE__ */ new Map(),
     enumIndexes: /* @__PURE__ */ new Map(),
@@ -3668,6 +4238,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
   function clearAll() {
     state.invertedIdx.clear();
     state.docStore.clear();
+    state.surfaceRegistry.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();
@@ -3818,6 +4389,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
       }
       bytes += totalPostings * POSTING_ENTRY_SIZE;
       bytes += termCount * PER_TERM_OVERHEAD;
+      const SURFACE_ENTRY_OVERHEAD = 140;
+      bytes += state.surfaceRegistry.size() * SURFACE_ENTRY_OVERHEAD;
       const FIELD_ENTRY_OVERHEAD = 42;
       bytes += docCount * state.numericIndexes.size * FIELD_ENTRY_OVERHEAD;
       bytes += docCount * state.booleanIndexes.size * FIELD_ENTRY_OVERHEAD;
@@ -3837,8 +4410,11 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     computeFacets(docIds, config, schema) {
       return computeFacets(state, docIds, config, schema);
     },
-    suggestTerms(prefix, limit) {
-      return state.invertedIdx.prefixSearch(prefix, limit);
+    suggestTerms(surfacePrefix, stemmedPrefix, limit) {
+      return suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit);
+    },
+    expandTermPrefix(surfacePrefix, stemmedToken, maxExpansions) {
+      return expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions);
     },
     serialize(indexName, totalPartitions, language, schema) {
       return serializePartition(state, partitionId, indexName, totalPartitions, language, schema);
@@ -3899,9 +4475,15 @@ function createRebalancer() {
       });
       const newPartitions = [];
       for (let i = 0; i < newPartitionCount; i++) {
-        newPartitions.push(createPartitionIndex(i));
+        newPartitions.push(createPartitionIndex(i, manager.config.trackPositions ?? true));
       }
       let documentsProcessed = 0;
+      const insertOptions = {
+        validate: false,
+        stopWordOverride: manager.config.stopWords,
+        customTokenizer: manager.config.tokenizer,
+        collectSurfaces: manager.config.surfaceForms === true
+      };
       for (let chunkStart = 0; chunkStart < collectedDocs.length; chunkStart += CHUNK_SIZE) {
         const chunkEnd = Math.min(chunkStart + CHUNK_SIZE, collectedDocs.length);
         for (let i = chunkStart; i < chunkEnd; i++) {
@@ -3911,7 +4493,7 @@ function createRebalancer() {
           if (targetPartition.has(docId)) {
             continue;
           }
-          targetPartition.insert(docId, document, manager.schema, manager.language, { validate: false });
+          targetPartition.insert(docId, document, manager.schema, manager.language, insertOptions);
           documentsProcessed++;
         }
         onProgress?.({
@@ -4168,6 +4750,36 @@ function mergeFacets(partitionFacets) {
 }
 
 // src/search/fulltext.ts
+var PREFIX_MAX_EXPANSIONS = 50;
+function resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken) {
+  const term = params.term;
+  if (term === void 0) return void 0;
+  const unstemmed = tokenize(term, language, {
+    stem: false,
+    removeStopWords: true,
+    customTokenizer: options?.customTokenizer,
+    stopWordOverride: options?.stopWords
+  });
+  let surfacePrefix;
+  for (const t of unstemmed.tokens) {
+    if (t.position === lastToken.position) {
+      surfacePrefix = t.token;
+      break;
+    }
+  }
+  if (surfacePrefix === void 0 || surfacePrefix.length === 0) return void 0;
+  const expansions = partition.expandTermPrefix(surfacePrefix, lastToken.token, PREFIX_MAX_EXPANSIONS);
+  const terms = [];
+  for (const expanded of expansions) {
+    if (expanded !== lastToken.token) terms.push(expanded);
+  }
+  for (const qt of queryTokens) {
+    if (qt.token === lastToken.token) {
+      return { token: qt.token, terms };
+    }
+  }
+  return void 0;
+}
 function fulltextSearch(partition, params, language, schema, options) {
   if (!params.term || params.term.trim().length === 0) {
     return { scored: [], totalMatched: 0 };
@@ -4189,6 +4801,11 @@ function fulltextSearch(partition, params, language, schema, options) {
     return { scored: [], totalMatched: 0 };
   }
   const queryTokens = deduplicateTokens(queryTokenResult.tokens);
+  let prefixExpansion;
+  if (params.prefix === true && params.exact !== true) {
+    const lastToken = queryTokenResult.tokens[queryTokenResult.tokens.length - 1];
+    prefixExpansion = resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken);
+  }
   let filterBitset;
   if (params.filters) {
     filterBitset = partition.applyFiltersBitset(params.filters, schema);
@@ -4202,6 +4819,7 @@ function fulltextSearch(partition, params, language, schema, options) {
   const collectComponents = params.includeScoreComponents === true || params.termMatch !== void 0 && params.termMatch !== "any";
   const rawResult = partition.searchFulltext({
     queryTokens,
+    prefixExpansion,
     fields: params.fields,
     boost: params.boost,
     tolerance: params.tolerance ?? 0,
@@ -4217,7 +4835,14 @@ function fulltextSearch(partition, params, language, schema, options) {
   let scored = rawResult.scored;
   const termMatch = params.termMatch ?? "any";
   if (termMatch !== "any") {
-    scored = filterByTermCoverage(scored, queryTokens, termMatch, params.tolerance ?? 0, params.exact ?? false);
+    scored = filterByTermCoverage(
+      scored,
+      queryTokens,
+      termMatch,
+      params.tolerance ?? 0,
+      params.exact ?? false,
+      prefixExpansion
+    );
   }
   if (params.minScore !== void 0 && params.minScore > 0) {
     const threshold = params.minScore;
@@ -4252,26 +4877,40 @@ function deduplicateTokens(tokens) {
   }
   return result;
 }
-function filterByTermCoverage(scored, queryTokens, policy, tolerance, exact) {
+function filterByTermCoverage(scored, queryTokens, policy, tolerance, exact, prefixExpansion) {
   const requiredCount = policy === "all" ? queryTokens.length : policy;
   if (requiredCount <= 0) return scored;
   if (requiredCount > queryTokens.length) return [];
+  const expansionTerms = prefixExpansion ? new Set(prefixExpansion.terms) : void 0;
   return scored.filter((doc) => {
-    const matched = countDocTermMatches(doc, queryTokens, tolerance, exact);
+    const matched = countDocTermMatches(doc, queryTokens, tolerance, exact, prefixExpansion?.token, expansionTerms);
     return matched >= requiredCount;
   });
 }
-function countDocTermMatches(doc, queryTokens, tolerance, exact) {
+function countDocTermMatches(doc, queryTokens, tolerance, exact, prefixToken, expansionTerms) {
   const indexTokens = Object.keys(doc.idf);
   if (indexTokens.length === 0) return 0;
   let count = 0;
   for (const qt of queryTokens) {
+    if (prefixToken !== void 0 && qt.token === prefixToken) {
+      if (prefixTokenSatisfied(qt.token, indexTokens, expansionTerms)) {
+        count++;
+      }
+      continue;
+    }
     if (queryTermSatisfied(qt.token, indexTokens, tolerance, exact)) {
       count++;
     }
   }
   return count;
 }
+function prefixTokenSatisfied(prefixToken, indexTokens, expansionTerms) {
+  for (const indexToken of indexTokens) {
+    if (indexToken === prefixToken) return true;
+    if (expansionTerms?.has(indexToken)) return true;
+  }
+  return false;
+}
 function queryTermSatisfied(queryToken, indexTokens, tolerance, exact) {
   if (exact || tolerance === 0) {
     return indexTokens.includes(queryToken);
@@ -4531,13 +5170,15 @@ function createPartitionManager(indexName, config, language, router, initialPart
   function resolveInsertOptions(options) {
     const applyStrict = config.strict === true;
     const applyAnalyzer = config.stopWords !== void 0 || config.tokenizer !== void 0;
-    if (!applyStrict && !applyAnalyzer) return options;
+    const applySurfaces = config.surfaceForms === true;
+    if (!applyStrict && !applyAnalyzer && !applySurfaces) return options;
     const resolved = { ...options };
     if (applyStrict) resolved.strict = true;
     if (applyAnalyzer) {
       resolved.stopWordOverride = options?.stopWordOverride ?? config.stopWords;
       resolved.customTokenizer = options?.customTokenizer ?? config.tokenizer;
     }
+    if (applySurfaces) resolved.collectSurfaces = true;
     return resolved;
   }
   function rebuildDocPartitionMap() {
@@ -4634,7 +5275,7 @@ function createPartitionManager(indexName, config, language, router, initialPart
       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);
+      partitions[pid].remove(docId, config.schema, language, resolveInsertOptions());
       docPartitionMap.delete(docId);
     },
     beginBatchRemove() {
@@ -7625,141 +8266,6 @@ function readHeader(data) {
     reserved
   };
 }
-var VALID_HNSW_METRICS2 = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
-function validateHnswMetric2(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS2.has(value)) {
-    return value;
-  }
-  return void 0;
-}
-function wireToPartition(raw) {
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
-    invertedIndex[token] = {
-      docFrequency: list.doc_freq,
-      postings: (list.postings ?? []).map((p) => ({
-        docId: p.doc_id,
-        termFrequency: p.term_freq,
-        field: p.field,
-        positions: p.positions ?? []
-      }))
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data.dimension,
-      vectors: (data.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data.hnsw_graph ? {
-        entryPoint: data.hnsw_graph.entry_point,
-        maxLayer: data.hnsw_graph.max_layer,
-        m: data.hnsw_graph.m,
-        efConstruction: data.hnsw_graph.ef_construction,
-        metric: validateHnswMetric2(data.hnsw_graph.metric),
-        nodes: data.hnsw_graph.nodes
-      } : null,
-      sq8: data.sq8 ? {
-        alpha: data.sq8.alpha,
-        offset: data.sq8.offset,
-        quantizedVectors: data.sq8.quantized_vectors,
-        vectorSums: data.sq8.vector_sums,
-        vectorSumSqs: data.sq8.vector_sum_sqs
-      } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint
-    },
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
-function deserializePayloadV1(data) {
-  const raw = decode(data);
-  return wireToPartition(raw);
-}
-function metadataToWire(meta) {
-  const wire = {
-    index_name: meta.indexName,
-    schema: meta.schema,
-    language: meta.language,
-    partition_count: meta.partitionCount,
-    bm25_params: meta.bm25Params,
-    created_at: meta.createdAt,
-    engine_version: meta.engineVersion
-  };
-  if (meta.vectorFields) {
-    wire.vector_fields = meta.vectorFields;
-  }
-  if (meta.embedding) {
-    wire.embedding = meta.embedding.adapter !== void 0 ? { adapter: meta.embedding.adapter, fields: meta.embedding.fields } : { fields: meta.embedding.fields };
-  }
-  return wire;
-}
-function wireToMetadata(raw) {
-  const meta = {
-    indexName: raw.index_name,
-    schema: raw.schema ?? {},
-    language: raw.language ?? "english",
-    partitionCount: raw.partition_count ?? 1,
-    bm25Params: raw.bm25_params ?? { k1: 1.2, b: 0.75 },
-    createdAt: raw.created_at ?? 0,
-    engineVersion: raw.engine_version ?? "0.0.0"
-  };
-  if (raw.vector_fields) {
-    meta.vectorFields = raw.vector_fields;
-  }
-  if (raw.embedding && typeof raw.embedding === "object" && typeof raw.embedding.fields === "object") {
-    meta.embedding = typeof raw.embedding.adapter === "string" ? { adapter: raw.embedding.adapter, fields: raw.embedding.fields } : { fields: raw.embedding.fields };
-  }
-  return meta;
-}
-function serializeMetadata(meta) {
-  const wire = metadataToWire(meta);
-  return encode(wire);
-}
-function deserializeMetadata(data) {
-  const raw = decode(data);
-  return wireToMetadata(raw);
-}
 
 // src/serialization/envelope.ts
 var CURRENT_ENVELOPE_VERSION = 1;
@@ -8775,6 +9281,7 @@ function mergeTimeOrderedSegments(ordered, fallback) {
     collectDocuments(merged, part, winner, segIndex);
     collectInvertedIndex(merged, part, winner, segIndex);
     collectFieldIndexes(merged, part, winner, segIndex);
+    collectSurfaceForms(merged, part);
   }
   recomputeStatistics(merged);
   validateMergedPartition(merged);
@@ -8902,6 +9409,26 @@ function collectFieldIndexes(merged, part, winner, segIndex) {
     }
   }
 }
+function collectSurfaceForms(merged, part) {
+  if (!part.surfaceForms) return;
+  let target = merged.surfaceForms;
+  if (!target) {
+    target = /* @__PURE__ */ Object.create(null);
+    merged.surfaceForms = target;
+  }
+  for (const [surface, value] of Object.entries(part.surfaceForms)) {
+    const count = typeof value === "number" ? value : value[0];
+    const token = typeof value === "number" ? surface : value[1];
+    const existing = target[surface];
+    if (existing === void 0) {
+      target[surface] = value;
+      continue;
+    }
+    const existingCount = typeof existing === "number" ? existing : existing[0];
+    const total = existingCount + count;
+    target[surface] = token === surface ? total : [total, token];
+  }
+}
 function recomputeStatistics(merged) {
   const totalFieldLengths = /* @__PURE__ */ Object.create(null);
   let totalDocuments = 0;
@@ -9112,6 +9639,9 @@ function reconstructSchemaFromMetadata(metadata) {
   if (metadata.embedding) {
     config.embedding = metadata.embedding.adapter !== void 0 ? { adapter: metadata.embedding.adapter, fields: metadata.embedding.fields } : { fields: metadata.embedding.fields };
   }
+  if (metadata.surfaceForms === true) {
+    config.surfaceForms = true;
+  }
   return config;
 }
 
@@ -10572,6 +11102,9 @@ function buildMetadata(indexName, hooks) {
   if (config.embedding) {
     metadata.embedding = config.embedding;
   }
+  if (config.surfaceForms) {
+    metadata.surfaceForms = true;
+  }
   return metadata;
 }
 function createDurabilityIntegration(tier, hooks) {
@@ -11102,7 +11635,8 @@ function createDurabilityFromConfig(config, wiring) {
         language: entry.language.name,
         k1: entry.config.bm25?.k1 ?? 1.2,
         b: entry.config.bm25?.b ?? 0.75,
-        ...embedding !== void 0 ? { embedding } : {}
+        ...embedding !== void 0 ? { embedding } : {},
+        ...entry.config.surfaceForms === true ? { surfaceForms: true } : {}
       };
     },
     createIndexFromMetadata: wiring.createIndexFromMetadata,
@@ -12586,10 +13120,15 @@ function highlightField(text, queryTokens, language, options) {
     return qt.token.toLowerCase();
   });
   const matchedRanges = [];
+  const prefixToken = options?.prefixToken;
   for (let i = 0; i < fieldResult.tokens.length; i++) {
     if (i >= charOffsets.length) break;
     const fieldToken = fieldResult.tokens[i].token;
     const stemmedField = language.stemmer ? language.stemmer(fieldToken) : fieldToken;
+    if (prefixToken !== void 0 && fieldToken.startsWith(prefixToken)) {
+      matchedRanges.push({ start: charOffsets[i].start, end: charOffsets[i].end });
+      continue;
+    }
     for (const stemmedQuery of stemmedQueryTokens) {
       if (stemmedField === stemmedQuery) {
         matchedRanges.push({ start: charOffsets[i].start, end: charOffsets[i].end });
@@ -12633,6 +13172,22 @@ function applyHighlights(hits, params, language, config) {
     customTokenizer: config.tokenizer,
     stopWordOverride: config.stopWords
   });
+  let prefixToken;
+  if (params.prefix === true && params.exact !== true && queryTokenResult.tokens.length > 0) {
+    const lastPosition = queryTokenResult.tokens[queryTokenResult.tokens.length - 1].position;
+    const unstemmed = tokenize(params.term ?? "", language, {
+      stem: false,
+      removeStopWords: true,
+      customTokenizer: config.tokenizer,
+      stopWordOverride: config.stopWords
+    });
+    for (const t of unstemmed.tokens) {
+      if (t.position === lastPosition) {
+        prefixToken = t.token;
+        break;
+      }
+    }
+  }
   for (const hit of hits) {
     const highlights = {};
     for (const field of params.highlight.fields) {
@@ -12642,7 +13197,8 @@ function applyHighlights(hits, params, language, config) {
         highlights[field] = highlightField(fieldValue, queryTokenResult.tokens, language, {
           preTag: params.highlight.preTag,
           postTag: params.highlight.postTag,
-          maxSnippetLength: params.highlight.maxSnippetLength
+          maxSnippetLength: params.highlight.maxSnippetLength,
+          prefixToken
         });
       }
     }
@@ -13291,25 +13847,36 @@ function executeSuggest(manager, language, params) {
     return { terms: [], elapsed: performance.now() - t0 };
   }
   const stemmed = language.stemmer ? language.stemmer(lastToken) : lastToken;
-  const prefixes = stemmed !== lastToken ? [lastToken, stemmed] : [lastToken];
-  const partitions = manager.getAllPartitions();
   const merged = /* @__PURE__ */ new Map();
   const perPartitionLimit = limit * 2;
-  for (const partition of partitions) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const prefix of prefixes) {
-      const suggestions = partition.suggestTerms(prefix, perPartitionLimit);
-      for (const s of suggestions) {
-        if (seen.has(s.term)) continue;
-        seen.add(s.term);
-        merged.set(s.term, (merged.get(s.term) ?? 0) + s.documentFrequency);
+  for (const partition of manager.getAllPartitions()) {
+    for (const suggestion of partition.suggestTerms(lastToken, stemmed, perPartitionLimit)) {
+      let entry = merged.get(suggestion.token);
+      if (!entry) {
+        entry = { documentFrequency: 0, surfaceOccurrences: /* @__PURE__ */ new Map() };
+        merged.set(suggestion.token, entry);
+      }
+      entry.documentFrequency += suggestion.documentFrequency;
+      for (const s of suggestion.surfaces) {
+        entry.surfaceOccurrences.set(s.surface, (entry.surfaceOccurrences.get(s.surface) ?? 0) + s.occurrences);
       }
     }
   }
-  const terms = Array.from(merged.entries()).map(([term, documentFrequency]) => ({ term, documentFrequency })).sort((a, b) => b.documentFrequency - a.documentFrequency);
+  const terms = Array.from(merged.values()).map((entry) => ({ term: pickDisplaySurface(entry.surfaceOccurrences), documentFrequency: entry.documentFrequency })).sort((a, b) => b.documentFrequency - a.documentFrequency || (a.term < b.term ? -1 : 1));
   if (terms.length > limit) terms.length = limit;
   return { terms, elapsed: performance.now() - t0 };
 }
+function pickDisplaySurface(surfaceOccurrences) {
+  let best = "";
+  let bestCount = -1;
+  for (const [surface, occurrences] of surfaceOccurrences) {
+    if (occurrences > bestCount || occurrences === bestCount && surface < best) {
+      best = surface;
+      bestCount = occurrences;
+    }
+  }
+  return best;
+}
 
 // src/engine/vector-maintenance.ts
 function resolveVectorIndexes(manager, indexName, fieldName) {