@delali/narsil 0.3.1-next.71 → 0.3.1-next.72

package/dist/{chunk-M76V3OGJ.mjs → chunk-HVJYTKK7.mjs}

@@ -1,11 +1,13 @@
-import { getLanguage, detectRuntime } from './chunk-HWQLTLNG.mjs';
-import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, bitsetHas, createBitSet, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, bitsetSet, tokenize, bitsetFromSet, getAllInternalDocIds, getFieldValueByInternalId, getOrCreateFieldNameIndex, tokenizeIterator, polygonContainment, requireValidOperands, bitsetAnd, bitsetOr, bitsetNot, requirePolygonRing, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-LMO5TJUS.mjs';
-import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, requireValidFieldTypes, extractVectorFieldsFromSchema, VECTOR_PATTERN, parsedTypeOf, isListBase } from './chunk-653BNMAF.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-YJDQ7NLA.mjs';
-import { noteFallback } from './chunk-YNVIUGF5.mjs';
+import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-QR4OKRVY.mjs';
+import { getLanguage, detectRuntime } from './chunk-KZTI25D3.mjs';
+import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, requireValidFieldTypes, extractVectorFieldsFromSchema, VECTOR_PATTERN, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-M6XF5HDE.mjs';
+import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-LCCL6EEH.mjs';
+import { noteFallback } from './chunk-P2ZZN32C.mjs';
 import { VALID_HNSW_METRICS } from './chunk-IFBKLBGB.mjs';
-import { compareCodePoints, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-OI42GWLR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { GrowableUint32, patternSearchModule } from './chunk-3HQPUCCT.mjs';
+import { bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-ZKRV5M2P.mjs';
+import { compareCodePoints, appendFoldedCodePoint, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
 import { encode, decode } from '@msgpack/msgpack';
@@ -398,6 +400,44 @@ function sanitizeSurfaceForms(raw) {
   }
   return count > 0 ? result : void 0;
 }
+function patternIndexesToWire(pattern) {
+  if (pattern === void 0) return {};
+  const wire = /* @__PURE__ */ Object.create(null);
+  for (const [field, index] of Object.entries(pattern)) wire[field] = { doc_ids: index.docIds, runs: index.runs };
+  return { pattern: wire };
+}
+function isWireRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function corruptPatternEntry(field) {
+  return new NarsilError(
+    ErrorCodes.PERSISTENCE_LOAD_FAILED,
+    `The pattern entry of field "${field}" in this partition must hold a list of document IDs and a map of runs`,
+    { field }
+  );
+}
+function patternIndexesFromWire(raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (!isWireRecord(raw)) {
+    throw new NarsilError(
+      ErrorCodes.PERSISTENCE_LOAD_FAILED,
+      "The pattern entry of this partition must be a map of fields"
+    );
+  }
+  const pattern = /* @__PURE__ */ Object.create(null);
+  for (const [field, index] of Object.entries(raw)) {
+    if (!isWireRecord(index) || !isWireRecord(index.runs) || !Array.isArray(index.doc_ids)) {
+      throw corruptPatternEntry(field);
+    }
+    const docIds = [];
+    for (const docId of index.doc_ids) {
+      if (typeof docId !== "string") throw corruptPatternEntry(field);
+      docIds.push(docId);
+    }
+    pattern[field] = { docIds, runs: index.runs };
+  }
+  return { pattern };
+}
 function validateHnswMetric(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
@@ -469,7 +509,8 @@ function wireToPartition(raw) {
       numeric,
       boolean,
       enum: raw.field_indexes?.enum ?? {},
-      geopoint
+      geopoint,
+      ...patternIndexesFromWire(raw.field_indexes?.pattern)
     },
     surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
     vectorData,
@@ -576,7 +617,8 @@ function deserializePayloadV2(data) {
       numeric,
       boolean,
       enum: raw.field_indexes?.enum ?? {},
-      geopoint
+      geopoint,
+      ...patternIndexesFromWire(raw.field_indexes?.pattern)
     },
     surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
     vectorData,
@@ -1411,8 +1453,55 @@ function createSurfaceRegistry() {
   };
 }
 
+// src/core/pattern-index/platform.ts
+function platformPatternSearch() {
+  return patternSearchModule;
+}
+
+// src/core/pattern-index/registry.ts
+var registered = null;
+function isPatternSearchModule(value) {
+  return value !== null && typeof value === "object" && value.name === "pattern" && "createIndex" in value && typeof value.createIndex === "function" && "readArrays" in value && typeof value.readArrays === "function" && "mergeArrays" in value && typeof value.mergeArrays === "function" && "matchInto" in value && typeof value.matchInto === "function";
+}
+function registerPatternSearch(module) {
+  if (!isPatternSearchModule(module)) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      'registerPatternSearch takes the patternSearch object that "@delali/narsil/pattern" exports'
+    );
+  }
+  registered = module;
+}
+function availablePatternSearch() {
+  return registered ?? platformPatternSearch();
+}
+function requirePatternSearchFor(schema) {
+  for (const { path, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) requirePatternSearch(path);
+  }
+}
+function requirePatternSearch(fieldPath) {
+  const module = availablePatternSearch();
+  if (module !== null) return module;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `Field "${fieldPath}" is a pattern field, but this bundle contains no pattern search code. Add import { patternSearch } from '@delali/narsil/pattern', then call registerPatternSearch(patternSearch) before you create or load the index`,
+    { field: fieldPath }
+  );
+}
+
+// src/core/pattern-index/host.ts
+var PATTERN_HOST = { appendFoldedCodePoint };
+function patternIndexOf(indexes, fieldPath) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = requirePatternSearch(fieldPath).createIndex(PATTERN_HOST);
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+
 // src/geo/haversine.ts
-var EARTH_RADIUS_METERS = 63710088e-1;
 function haversineDistance(lat1, lon1, lat2, lon2) {
   const phi1 = lat1 * DEG_TO_RAD;
   const phi2 = lat2 * DEG_TO_RAD;
@@ -1475,61 +1564,94 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
 }
 
 // src/geo/geo-index.ts
+function firstAtOrAfter(entries, code) {
+  let lo = 0;
+  let hi = entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (entries[mid].code < code) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
 function createGeoIndex() {
   const entries = [];
-  return {
-    get entries() {
-      return entries;
-    },
+  const byDocument = /* @__PURE__ */ new Map();
+  let sorted = true;
+  function ensureSorted() {
+    if (sorted) return;
+    entries.sort((left, right) => left.code - right.code || left.docId - right.docId);
+    sorted = true;
+  }
+  function removeEntry(internalId) {
+    const entry = byDocument.get(internalId);
+    if (entry === void 0) return;
+    byDocument.delete(internalId);
+    ensureSorted();
+    for (let at = firstAtOrAfter(entries, entry.code); at < entries.length; at++) {
+      if (entries[at] !== entry) continue;
+      entries.splice(at, 1);
+      return;
+    }
+  }
+  function matching(boxes, passes, inside) {
+    ensureSorted();
+    const within = /* @__PURE__ */ new Set();
+    for (const range of coveringRanges(boxes)) {
+      for (let at = firstAtOrAfter(entries, range.from); at < entries.length && entries[at].code < range.to; at++) {
+        if (passes(entries[at])) within.add(entries[at].docId);
+      }
+    }
+    if (inside) return within;
+    const outside = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (!within.has(entry.docId)) outside.add(entry.docId);
+    }
+    return outside;
+  }
+  const index = {
     insert(internalId, lat, lon) {
-      entries.push({ lat, lon, docId: internalId });
+      removeEntry(internalId);
+      const entry = { lat, lon, docId: internalId, code: locationCode(lat, lon) };
+      entries.push(entry);
+      byDocument.set(internalId, entry);
+      sorted = false;
     },
     remove(internalId) {
-      for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].docId === internalId) {
-          entries.splice(i, 1);
-          return;
-        }
-      }
+      removeEntry(internalId);
     },
     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;
+      return matching(
+        radiusBoxes(lat, lon, distanceMeters),
+        (entry) => distanceFn(lat, lon, entry.lat, entry.lon) <= distanceMeters,
+        inside
+      );
     },
     polygonQuery(points, inside) {
-      const result = /* @__PURE__ */ new Set();
       const contains = polygonContainment(points);
-      for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        const withinPolygon = contains(entry.lat, entry.lon);
-        if (inside ? withinPolygon : !withinPolygon) {
-          result.add(entry.docId);
-        }
-      }
-      return result;
+      return matching(polygonBoxes(points), (entry) => contains(entry.lat, entry.lon), inside);
+    },
+    documentsBitset(capacity) {
+      const bits = createBitSet(capacity);
+      for (const entry of entries) bitsetSet(bits, entry.docId);
+      return bits;
     },
     clear() {
       entries.length = 0;
+      byDocument.clear();
+      sorted = true;
     },
     serialize() {
-      return entries.map((e) => ({ ...e }));
+      ensureSorted();
+      return entries.map((entry) => ({ lat: entry.lat, lon: entry.lon, docId: entry.docId }));
     },
     deserialize(data) {
-      entries.length = 0;
-      for (const entry of data) {
-        entries.push({ lat: entry.lat, lon: entry.lon, docId: entry.docId });
-      }
+      index.clear();
+      for (const entry of data) index.insert(entry.docId, entry.lat, entry.lon);
     }
   };
+  return index;
 }
 
 // src/core/field-index/boolean.ts
@@ -1603,9 +1725,90 @@ function createBooleanIndex() {
   };
 }
 
+// src/core/field-index/affixes.ts
+function compareUnits(left, right) {
+  if (left < right) return -1;
+  return left > right ? 1 : 0;
+}
+function reversedUnits(value) {
+  let reversed = "";
+  for (let at = value.length - 1; at >= 0; at--) reversed += value[at];
+  return reversed;
+}
+function firstAtOrAfter2(sorted, key) {
+  let lo = 0;
+  let hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (sorted[mid] < key) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function settledColumn(column, holds) {
+  const { keys, values } = column;
+  const order = [];
+  for (let at = 0; at < keys.length; at++) if (holds(values[at])) order.push(at);
+  order.sort((left, right) => compareUnits(keys[left], keys[right]) || compareUnits(values[left], values[right]));
+  const settled = { keys: [], values: [] };
+  for (const at of order) {
+    const last = settled.values.length - 1;
+    if (last >= 0 && settled.keys[last] === keys[at] && settled.values[last] === values[at]) continue;
+    settled.keys.push(keys[at]);
+    settled.values.push(values[at]);
+  }
+  return settled;
+}
+var ValueAffixes = class {
+  constructor(holds, values) {
+    this.holds = holds;
+    for (const value of values) this.add(value);
+  }
+  forward = { keys: [], values: [] };
+  backward = { keys: [], values: [] };
+  settled = true;
+  add(value) {
+    this.forward.keys.push(value);
+    this.forward.values.push(value);
+    this.backward.keys.push(reversedUnits(value));
+    this.backward.values.push(value);
+    this.settled = false;
+  }
+  forget() {
+    this.settled = false;
+  }
+  withPrefix(prefix) {
+    this.settle();
+    return this.matching(this.forward, prefix);
+  }
+  withSuffix(suffix) {
+    this.settle();
+    return this.matching(this.backward, reversedUnits(suffix));
+  }
+  settle() {
+    if (this.settled) return;
+    this.forward = settledColumn(this.forward, this.holds);
+    this.backward = settledColumn(this.backward, this.holds);
+    this.settled = true;
+  }
+  matching(column, start) {
+    const found = [];
+    for (let at = firstAtOrAfter2(column.keys, start); at < column.keys.length; at++) {
+      if (!column.keys[at].startsWith(start)) break;
+      found.push(column.values[at]);
+    }
+    return found;
+  }
+};
+
 // src/core/field-index/enum.ts
 function createEnumIndex() {
   const valueMap = /* @__PURE__ */ new Map();
+  let affixes = null;
+  function affixesOf() {
+    affixes ??= new ValueAffixes((value) => valueMap.has(value), valueMap.keys());
+    return affixes;
+  }
   function allDocs() {
     const result = /* @__PURE__ */ new Set();
     for (const docSet of valueMap.values()) {
@@ -1619,6 +1822,7 @@ function createEnumIndex() {
       if (!docSet) {
         docSet = /* @__PURE__ */ new Set();
         valueMap.set(value, docSet);
+        affixes?.add(value);
       }
       docSet.add(internalId);
     },
@@ -1626,7 +1830,15 @@ function createEnumIndex() {
       const docSet = valueMap.get(value);
       if (!docSet) return;
       docSet.delete(internalId);
-      if (docSet.size === 0) valueMap.delete(value);
+      if (docSet.size > 0) return;
+      valueMap.delete(value);
+      affixes?.forget();
+    },
+    queryPrefixBitset(prefix, capacity) {
+      return this.queryInBitset(affixesOf().withPrefix(prefix), capacity);
+    },
+    querySuffixBitset(suffix, capacity) {
+      return this.queryInBitset(affixesOf().withSuffix(suffix), capacity);
     },
     queryEq(value) {
       const docSet = valueMap.get(value);
@@ -1702,6 +1914,7 @@ function createEnumIndex() {
     },
     clear() {
       valueMap.clear();
+      affixes = null;
     },
     serialize() {
       const result = /* @__PURE__ */ Object.create(null);
@@ -1712,6 +1925,7 @@ function createEnumIndex() {
     },
     deserialize(data) {
       valueMap.clear();
+      affixes = null;
       for (const value of Object.keys(data)) {
         valueMap.set(value, new Set(data[value]));
       }
@@ -1893,6 +2107,44 @@ function createNumericIndex() {
   };
 }
 
+// src/core/partition/value-sizes.ts
+function keepsValueSize(base) {
+  return base === "string" || base === "verbatim" || base.endsWith("[]");
+}
+function valueSizeOf(value) {
+  if (Array.isArray(value)) return value.length;
+  return value === "" ? 0 : 1;
+}
+function sizeIndexOf(indexes, fieldPath) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = createNumericIndex();
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+function recordValueSize(indexes, internalId, fieldPath, base, value) {
+  if (value === void 0 || value === null || !keepsValueSize(base)) return;
+  sizeIndexOf(indexes, fieldPath).insert(internalId, valueSizeOf(value));
+}
+function forgetValueSize(indexes, internalId, fieldPath, base, value) {
+  if (value === void 0 || value === null || !keepsValueSize(base)) return;
+  indexes.get(fieldPath)?.remove(internalId, valueSizeOf(value));
+}
+function rebuildSizeIndexes(state, schema) {
+  state.sizeIndexes.clear();
+  const fields = schemaFieldsOf(schema).filter((field) => keepsValueSize(field.base));
+  if (fields.length === 0) return;
+  for (const [docId, stored] of state.docStore.all()) {
+    const internalId = state.docStore.getInternalId(docId);
+    if (internalId === void 0) continue;
+    for (const { path, base } of fields) {
+      const value = getNestedValue(stored.fields, path);
+      recordValueSize(state.sizeIndexes, internalId, path, base, value);
+    }
+  }
+}
+
 // src/core/partition/indexing.ts
 function ensureFieldIndex(state, fieldPath, base) {
   if ((base === "number" || base === "number[]") && !state.numericIndexes.has(fieldPath)) {
@@ -2031,10 +2283,12 @@ function indexDocument(state, docId, document, fields, language, options) {
   const fieldLengths = {};
   const tokensByField = {};
   const internalId = resolveInternalId(state, docId);
-  for (const { path: fieldPath, base } of fields) {
+  for (const { path: fieldPath, base, pattern } of fields) {
     const value = getNestedValue(document, fieldPath);
     if (value === void 0 || value === null) continue;
+    recordValueSize(state.sizeIndexes, internalId, fieldPath, base, value);
     ensureFieldIndex(state, fieldPath, base);
+    if (pattern) patternIndexOf(state.patternIndexes, fieldPath).add(internalId, value);
     if (base === "string") {
       indexStringField(state, internalId, fieldPath, value, language, options, fieldLengths, tokensByField);
     } else if (base === "number") {
@@ -2078,9 +2332,11 @@ function removeFromIndexes(state, docId, storedDoc, schemaFields, language, opti
   const fields = storedDoc.fields;
   const internalId = resolveInternalId(state, docId);
   const opts = tokenizeOptions(options);
-  for (const { path: fieldPath, base } of schemaFields) {
+  for (const { path: fieldPath, base, pattern } of schemaFields) {
     const value = getNestedValue(fields, fieldPath);
     if (value === void 0 || value === null) continue;
+    forgetValueSize(state.sizeIndexes, internalId, fieldPath, base, value);
+    if (pattern) state.patternIndexes.get(fieldPath)?.remove(internalId, value);
     if (base === "string") {
       const result = tokenize(value, language, opts);
       fieldLengths[fieldPath] = result.tokens.length;
@@ -2152,16 +2408,24 @@ function resolveInternalId2(state, docId) {
 }
 function updateFieldIndexOnly(state, docId, oldFields, newDoc, fields) {
   const internalId = resolveInternalId2(state, docId);
-  for (const { path: fieldPath, base: fieldType } of fields) {
+  for (const { path: fieldPath, base: fieldType, pattern } of fields) {
     if (isWordIndexedBase(fieldType)) 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;
+    forgetValueSize(state.sizeIndexes, internalId, fieldPath, fieldType, oldVal);
+    recordValueSize(state.sizeIndexes, internalId, fieldPath, fieldType, newVal);
     if (newVal !== void 0 && newVal !== null) {
       ensureFieldIndex(state, fieldPath, fieldType);
     }
+    if (pattern) {
+      if (oldVal !== void 0 && oldVal !== null) state.patternIndexes.get(fieldPath)?.remove(internalId, oldVal);
+      if (newVal !== void 0 && newVal !== null) {
+        patternIndexOf(state.patternIndexes, fieldPath).add(internalId, newVal);
+      }
+    }
     if (fieldType === "number") {
       const numIdx = state.numericIndexes.get(fieldPath);
       if (numIdx) {
@@ -2223,27 +2487,218 @@ function updateFieldIndexOnly(state, docId, oldFields, newDoc, fields) {
   }
 }
 
-// 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]);
+// src/filters/pattern-tests.ts
+function excluding(context, fieldPath, excluded) {
+  const universe = bitsetAnd(context.presentBitset(fieldPath), context.allDocIdsBitset);
+  return bitsetAnd(universe, bitsetNot(excluded, context.capacity));
+}
+function textsOf(operand) {
+  const texts = /* @__PURE__ */ new Set();
+  if (!Array.isArray(operand)) return texts;
+  for (const text of operand) if (typeof text === "string") texts.add(text);
+  return texts;
+}
+function evaluatePatternTests(fieldPath, filter, context, bitsets) {
+  const caseFold = filter.caseFold === true;
+  const matching = (operator, texts) => {
+    const into = createBitSet(context.capacity);
+    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, into);
+    return into;
+  };
+  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq]));
+  if (typeof filter.ne === "string") bitsets.push(excluding(context, fieldPath, matching("eq", [filter.ne])));
+  if (filter.in !== void 0) bitsets.push(matching("eq", textsOf(filter.in)));
+  if (filter.nin !== void 0) bitsets.push(excluding(context, fieldPath, matching("eq", textsOf(filter.nin))));
+  if (typeof filter.startsWith === "string") bitsets.push(matching("startsWith", [filter.startsWith]));
+  if (typeof filter.endsWith === "string") bitsets.push(matching("endsWith", [filter.endsWith]));
+  if (typeof filter.contains === "string") bitsets.push(matching("contains", [filter.contains]));
+}
+
+// src/filters/field-tests.ts
+var COMPARISON_OPERATORS = ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
+var TEXT_RANGE_OPERATORS = ["gt", "gte", "lt", "lte"];
+var FieldBits = class {
+  constructor(context, fieldPath) {
+    this.context = context;
+    this.fieldPath = fieldPath;
   }
-  return result;
+  none() {
+    return createBitSet(this.context.capacity);
+  }
+  present() {
+    return this.context.presentBitset(this.fieldPath);
+  }
+  holdingSomething() {
+    const empty = this.context.sizeIndex(this.fieldPath)?.queryEqBitset(0, this.context.capacity);
+    return empty === void 0 ? this.present() : this.without(this.present(), empty);
+  }
+  without(from, removed) {
+    const kept = from.slice();
+    bitsetAndNotInto(kept, removed);
+    return kept;
+  }
+  complement(bits) {
+    return this.without(this.context.allDocIdsBitset, bits);
+  }
+};
+function comparisonBits(index, operator, operand, bits, capacity) {
+  if (operator === "between") {
+    const [low, high] = operand;
+    return index?.queryBetweenBitset(low, high, capacity) ?? bits.none();
+  }
+  const value = operand;
+  if (operator === "ne") return bits.without(bits.present(), index?.queryEqBitset(value, capacity) ?? bits.none());
+  if (index === void 0) return bits.none();
+  if (operator === "eq") return index.queryEqBitset(value, capacity);
+  if (operator === "gt") return index.queryGtBitset(value, capacity);
+  if (operator === "gte") return index.queryGteBitset(value, capacity);
+  if (operator === "lt") return index.queryLtBitset(value, capacity);
+  return index.queryLteBitset(value, capacity);
+}
+function elementBits(context, fieldPath, parsed, value) {
+  const { capacity } = context;
+  if (parsed.pattern) {
+    const matches = createBitSet(capacity);
+    context.matchPattern(fieldPath, "eq", value, false, matches);
+    return matches;
+  }
+  if (typeof value === "number")
+    return context.numericIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
+  if (typeof value === "boolean")
+    return context.booleanIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
+  return context.enumIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
+}
+function anyElementBits(context, fieldPath, parsed, values) {
+  const { capacity } = context;
+  const union = createBitSet(capacity);
+  if (parsed.pattern) {
+    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, union);
+    return union;
+  }
+  if (parsed.base === "enum[]") {
+    return context.enumIndex(fieldPath)?.queryInBitset(values, capacity) ?? union;
+  }
+  const numbers = context.numericIndex(fieldPath);
+  const booleans = context.booleanIndex(fieldPath);
+  for (const value of values) {
+    if (typeof value === "number") for (const docId of numbers?.queryEq(value) ?? []) bitsetSet(union, docId);
+    if (typeof value === "boolean") for (const docId of booleans?.queryEq(value) ?? []) bitsetSet(union, docId);
+  }
+  return union;
+}
+function distinctScalars(values) {
+  return [...new Set(values)];
 }
-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]);
+function narrowByElements(fieldPath, f, parsed, context, bits, narrow) {
+  if (f.matchesAny !== void 0) narrow(anyElementBits(context, fieldPath, parsed, distinctScalars(f.matchesAny)));
+  if (f.containsAll !== void 0) {
+    const all = bits.present().slice();
+    for (const value of distinctScalars(f.containsAll)) {
+      if (bitsetIsEmpty(all)) break;
+      bitsetAndInto(all, elementBits(context, fieldPath, parsed, value));
+    }
+    narrow(all);
+  }
+  if (f.size !== void 0) {
+    const sizes = context.sizeIndex(fieldPath);
+    const comparison = f.size;
+    for (const operator of COMPARISON_OPERATORS) {
+      if (comparison[operator] === void 0) continue;
+      narrow(comparisonBits(sizes, operator, comparison[operator], bits, context.capacity));
+    }
+  }
+}
+function narrowByValue(fieldPath, f, parsed, context, bits, narrow) {
+  const { capacity } = context;
+  const base = parsed.base;
+  if (base === "number" || base === "number[]") {
+    const index = context.numericIndex(fieldPath);
+    for (const operator of COMPARISON_OPERATORS) {
+      const operand = f[operator];
+      if (operand === void 0 || typeof operand === "string") continue;
+      if (operator === "between" && typeof operand[0] === "string") continue;
+      narrow(comparisonBits(index, operator, operand, bits, capacity));
+    }
+    return;
+  }
+  if (base === "boolean" || base === "boolean[]") {
+    const index = context.booleanIndex(fieldPath);
+    const equal = (value) => index?.queryEqBitset(value, capacity) ?? bits.none();
+    if (typeof f.eq === "boolean") narrow(equal(f.eq));
+    if (typeof f.ne === "boolean") narrow(bits.without(bits.present(), equal(f.ne)));
+    return;
+  }
+  if (base === "enum" || base === "enum[]") {
+    const index = context.enumIndex(fieldPath);
+    const equal = (value) => index?.queryEqBitset(value, capacity) ?? bits.none();
+    const anyOf = (values) => index?.queryInBitset(values, capacity) ?? bits.none();
+    if (typeof f.eq === "string") narrow(equal(f.eq));
+    if (typeof f.ne === "string") narrow(bits.without(bits.present(), equal(f.ne)));
+    if (Array.isArray(f.in)) narrow(anyOf(f.in));
+    if (Array.isArray(f.nin)) narrow(bits.without(bits.present(), anyOf(f.nin)));
+    if (typeof f.startsWith === "string") narrow(index?.queryPrefixBitset(f.startsWith, capacity) ?? bits.none());
+    if (typeof f.endsWith === "string") narrow(index?.querySuffixBitset(f.endsWith, capacity) ?? bits.none());
+  }
+}
+function narrowByLocation(fieldPath, f, context, narrow) {
+  const index = context.geoIndex(fieldPath);
+  if (f.radius !== void 0) {
+    const circle = f.radius;
+    const found = index?.radiusQuery(
+      circle.lat,
+      circle.lon,
+      circle.distance * GEO_UNIT_METRES[circle.unit],
+      circle.inside ?? true,
+      circle.highPrecision ?? false
+    );
+    narrow(bitsetFromSet(found ?? /* @__PURE__ */ new Set(), context.capacity));
+  }
+  if (f.polygon !== void 0) {
+    const polygon = f.polygon;
+    narrow(bitsetFromSet(index?.polygonQuery(polygon.points, polygon.inside ?? true) ?? /* @__PURE__ */ new Set(), context.capacity));
+  }
+}
+function narrowByPresence(f, bits, narrow) {
+  if (typeof f.exists === "boolean") narrow(f.exists ? bits.present() : bits.complement(bits.present()));
+  if (typeof f.notExists === "boolean") narrow(f.notExists ? bits.complement(bits.present()) : bits.present());
+  if (typeof f.isNotEmpty === "boolean") {
+    const holding = bits.holdingSomething();
+    narrow(f.isNotEmpty ? holding : bits.complement(holding));
+  }
+  if (typeof f.isEmpty === "boolean") {
+    const holding = bits.holdingSomething();
+    narrow(f.isEmpty ? bits.complement(holding) : holding);
   }
-  return result;
 }
-function applyNotBitset(excluded, capacity) {
-  return bitsetNot(excluded, capacity);
+function textBoundsOf(operator, bound) {
+  if (operator === "gt" || operator === "gte") {
+    return { lower: bound, upper: null, lowerInclusive: operator === "gte", upperInclusive: false };
+  }
+  return { lower: null, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
+}
+function narrowByTextRange(fieldPath, f, context, narrow) {
+  for (const operator of TEXT_RANGE_OPERATORS) {
+    const bound = f[operator];
+    if (typeof bound === "string") narrow(context.textRangeBitset(fieldPath, textBoundsOf(operator, bound)));
+  }
+  if (!Array.isArray(f.between)) return;
+  const [low, high] = f.between;
+  if (typeof low !== "string" || typeof high !== "string") return;
+  narrow(context.textRangeBitset(fieldPath, { lower: low, lowerInclusive: true, upper: high, upperInclusive: true }));
+}
+function narrowByFieldTests(fieldPath, f, parsed, context, narrow) {
+  const bits = new FieldBits(context, fieldPath);
+  narrowByPresence(f, bits, narrow);
+  narrowByLocation(fieldPath, f, context, narrow);
+  narrowByTextRange(fieldPath, f, context, narrow);
+  if (parsed.pattern) {
+    const patternBits = [];
+    evaluatePatternTests(fieldPath, f, context, patternBits);
+    for (const matched of patternBits) narrow(matched);
+  } else {
+    narrowByValue(fieldPath, f, parsed, context, bits, narrow);
+  }
+  narrowByElements(fieldPath, f, parsed, context, bits, narrow);
 }
 
 // src/filters/keys.ts
@@ -2260,6 +2715,8 @@ var FIELD_FILTER_OPERATORS = [
   "nin",
   "startsWith",
   "endsWith",
+  "contains",
+  "caseFold",
   "containsAll",
   "matchesAny",
   "size",
@@ -2271,229 +2728,7 @@ var FIELD_FILTER_OPERATORS = [
   "polygon"
 ];
 
-// 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;
-  if (unit === "m") return distance;
-  throw new NarsilError(
-    ErrorCodes.SEARCH_INVALID_FILTER,
-    `The engine measures a radius in "km", "mi", or "m", and "${String(unit)}" is none of them`,
-    { unit: String(unit) }
-  );
-}
-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;
-}
-function holdsValue(stored, value) {
-  return Array.isArray(stored) ? stored.includes(value) : stored === value;
-}
-function lacksValue(stored, value) {
-  if (stored === void 0 || stored === null) return false;
-  return Array.isArray(stored) ? !stored.includes(value) : stored !== value;
-}
-function isStringIn(values) {
-  return (element) => typeof element === "string" && values.has(element);
-}
-function holdsStringIn(stored, values) {
-  return Array.isArray(stored) ? stored.some(isStringIn(values)) : isStringIn(values)(stored);
-}
-function holdsNoStringIn(stored, values) {
-  if (Array.isArray(stored)) return !stored.some(isStringIn(values));
-  return typeof stored === "string" && !values.has(stored);
-}
-function holdsStringWhere(stored, test) {
-  const matches = (element) => typeof element === "string" && test(element);
-  return Array.isArray(stored) ? stored.some(matches) : matches(stored);
-}
-
-// 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 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) => holdsValue(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) => lacksValue(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);
-  }
-  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 applyInBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "enum") {
-    return fieldIndex.index.getDocIdsInBitset(values, capacity);
-  }
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringIn(v, valSet));
-}
-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));
-  }
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsNoStringIn(v, valSet));
-}
-function applyStartsWithBitset(prefix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.startsWith(prefix)));
-}
-function applyEndsWithBitset(suffix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.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;
-  });
-}
-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;
-    }
-    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) {
-  requirePolygonRing(filter.points);
-  const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
-  return bitsetFromSet(setResult, capacity);
-}
-
 // src/filters/evaluator.ts
-var UNBOUNDED = { lower: null, upper: null };
-function textBoundsOf(operator, bound) {
-  if (operator === "gt" || operator === "gte") {
-    return { ...UNBOUNDED, lower: bound, lowerInclusive: operator === "gte", upperInclusive: false };
-  }
-  return { ...UNBOUNDED, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
-}
-var TEXT_RANGE_OPERATORS = ["gt", "gte", "lt", "lte"];
 var EXPRESSION_KEYS = new Set(FILTER_EXPRESSION_KEYS);
 var OPERATOR_KEYS = new Set(FIELD_FILTER_OPERATORS);
 function requireKnownKeys(value, known, describe) {
@@ -2503,160 +2738,66 @@ function requireKnownKeys(value, known, describe) {
     }
   }
 }
+var Narrowing = class {
+  bits = null;
+  narrow = (matched) => {
+    if (this.bits === null) this.bits = matched.slice();
+    else bitsetAndInto(this.bits, matched);
+  };
+  value(universe) {
+    return this.bits ?? universe().slice();
+  }
+};
+function narrowByField(fieldPath, filter, context, narrow) {
+  requireKnownKeys(
+    filter,
+    OPERATOR_KEYS,
+    (key) => `Field "${fieldPath}" is tested with "${key}", which is no filter operator`
+  );
+  const type = context.fieldTypes[fieldPath];
+  const parsed = parsedTypeOf(type);
+  if (type === void 0 || parsed === void 0) throw undeclaredFilterField(fieldPath);
+  const f = filter;
+  requireValidOperands(fieldPath, f, type);
+  narrowByFieldTests(fieldPath, f, parsed, context, narrow.narrow);
+}
 function evaluateFilters(expression, context) {
   requireKnownKeys(
     expression,
     EXPRESSION_KEYS,
     (key) => `A filter expression takes "fields", "and", "or", and "not", and "${key}" is none of them. A per-field test such as { ${key}: { eq: ... } } belongs under "fields"`
   );
-  const bitsets = [];
+  const narrowing = new Narrowing();
   if (expression.fields) {
     for (const [fieldPath, filter] of Object.entries(expression.fields)) {
-      bitsets.push(evaluateFieldFilter(fieldPath, filter, context));
+      narrowByField(fieldPath, filter, context, narrowing);
     }
   }
   if (expression.and?.length) {
-    const andBitsets = expression.and.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyAndBitset(andBitsets));
+    for (const nested of expression.and) narrowing.narrow(evaluateFilters(nested, context));
   }
   if (expression.or?.length) {
-    const orBitsets = expression.or.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyOrBitset(orBitsets));
+    const union = createBitSet(context.capacity);
+    for (const nested of expression.or) bitsetOrInto(union, evaluateFilters(nested, context));
+    narrowing.narrow(union);
   }
   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 evaluateFieldFilter(fieldPath, filter, context) {
-  requireKnownKeys(
-    filter,
-    OPERATOR_KEYS,
-    (key) => `Field "${fieldPath}" is tested with "${key}", which is no filter operator`
-  );
-  const f = filter;
-  requireValidOperands(fieldPath, f, context.fieldTypes[fieldPath]);
-  const fieldIndex = context.fieldIndexes[fieldPath];
-  const getValue = (internalId) => context.getFieldValue(internalId, fieldPath);
-  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));
-  }
-  for (const operator of TEXT_RANGE_OPERATORS) {
-    const bound = f[operator];
-    if (typeof bound === "string") bitsets.push(context.textRangeBitset(fieldPath, textBoundsOf(operator, bound)));
-  }
-  if (typeof f.gt === "number") {
-    bitsets.push(applyGtBitset(f.gt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.lt === "number") {
-    bitsets.push(applyLtBitset(f.lt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.gte === "number") {
-    bitsets.push(applyGteBitset(f.gte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.lte === "number") {
-    bitsets.push(applyLteBitset(f.lte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (Array.isArray(f.between)) {
-    const [low, high] = f.between;
-    if (typeof low === "string" && typeof high === "string") {
-      bitsets.push(
-        context.textRangeBitset(fieldPath, { lower: low, lowerInclusive: true, upper: high, upperInclusive: true })
-      );
-    } else {
-      bitsets.push(
-        applyBetweenBitset([low, high], 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)
-    );
+    const kept = context.allDocIdsBitset.slice();
+    bitsetAndNotInto(kept, excluded);
+    narrowing.narrow(kept);
   }
-  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)
-    );
-  }
-  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 resolveGeoIndex(fieldPath, fieldIndex) {
-  if (fieldIndex?.type !== "geopoint") {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_FILTER,
-      `Field "${fieldPath}" requires a geopoint index for geo filters`,
-      { fieldPath }
-    );
-  }
-  return fieldIndex.index;
+  return narrowing.value(() => context.allDocIdsBitset);
 }
 
 // src/core/partition/constants.ts
 var TARGET_BLOCK_ENTRIES = 128;
 var PRUNING_REJECTION_SLACK = 1e-12;
 var SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY = 1024;
+var SEGMENT_TOKEN_TABLE_START = 1 << 12;
+var SEGMENT_POSTING_LOG_START = 1 << 14;
+var SEGMENT_POSITION_POOL_START = 1 << 16;
+var SEGMENT_FIELD_SCRATCH_START = 1 << 10;
 var SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD = 1024;
 var SORT_COLUMN_REBUILD_FRACTION_SHIFT = 2;
 
@@ -3273,99 +3414,72 @@ function sortColumnBytes(state) {
 }
 
 // src/core/partition/filters.ts
-var EMPTY_GEO_INDEX = {
-  radiusQuery: () => /* @__PURE__ */ new Set(),
-  polygonQuery: () => /* @__PURE__ */ new Set()
-};
-function buildFilterContext(state, schema) {
+function presentBitsetOf(state, fieldPath, type, capacity) {
+  const base = parsedTypeOf(type)?.base;
+  let present;
+  if (base === "number") present = state.numericIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "boolean") present = state.booleanIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "enum") present = state.enumIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "geopoint") present = state.geoIndexes.get(fieldPath)?.documentsBitset(capacity);
+  else if (base !== void 0 && keepsValueSize(base)) {
+    present = state.sizeIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  }
+  return present ?? createBitSet(capacity);
+}
+function liveDocumentsBitset(state, capacity) {
+  const bits = createBitSet(capacity);
+  for (const internalId of state.docStore.allInternalIds()) bitsetSet(bits, internalId);
+  return bits;
+}
+function buildFilterContext(state, schema, meter) {
   const flat = getFlatSchema(state, schema);
-  const fieldIndexes = {};
   const capacity = state.docStore.internalIdCapacity();
-  for (const { path: fieldPath, base: fieldType } of schemaFieldsOf(schema)) {
-    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);
-      fieldIndexes[fieldPath] = {
-        type: "geopoint",
-        index: geoIdx === void 0 ? EMPTY_GEO_INDEX : geoIdx
-      };
-    }
+  const patternFields = /* @__PURE__ */ new Set();
+  for (const { path: fieldPath, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) patternFields.add(fieldPath);
   }
-  let cachedAllDocIds = null;
+  const getFieldValue = (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath);
   let cachedAllDocIdsBitset = null;
+  const cachedPresentBitsets = /* @__PURE__ */ new Map();
   return {
     fieldTypes: flat,
-    fieldIndexes,
-    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
+    numericIndex: (fieldPath) => state.numericIndexes.get(fieldPath),
+    booleanIndex: (fieldPath) => state.booleanIndexes.get(fieldPath),
+    enumIndex: (fieldPath) => state.enumIndexes.get(fieldPath),
+    geoIndex: (fieldPath) => state.geoIndexes.get(fieldPath),
+    sizeIndex: (fieldPath) => state.sizeIndexes.get(fieldPath),
     textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
-    get allDocIds() {
-      if (!cachedAllDocIds) {
-        cachedAllDocIds = getAllInternalDocIds(state.docStore);
-      }
-      return cachedAllDocIds;
+    isPatternField: (fieldPath) => patternFields.has(fieldPath),
+    matchPattern: (fieldPath, operator, text, caseFold, into) => {
+      const index = state.patternIndexes.get(fieldPath);
+      if (index === void 0) return;
+      requirePatternSearch(fieldPath).matchInto({
+        operator,
+        text,
+        caseFold,
+        index,
+        matches: into,
+        meter,
+        host: PATTERN_HOST,
+        valueOf: (internalId) => getFieldValue(internalId, fieldPath)
+      });
+    },
+    presentBitset: (fieldPath) => {
+      const cached = cachedPresentBitsets.get(fieldPath);
+      if (cached !== void 0) return cached;
+      const present = presentBitsetOf(state, fieldPath, flat[fieldPath], capacity);
+      cachedPresentBitsets.set(fieldPath, present);
+      return present;
     },
     capacity,
     get allDocIdsBitset() {
-      if (!cachedAllDocIdsBitset) {
-        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
-      }
+      cachedAllDocIdsBitset ??= liveDocumentsBitset(state, capacity);
       return cachedAllDocIdsBitset;
     }
   };
 }
-function applyPartitionFilters(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
+function applyPartitionFilters(state, filters, schema, meter) {
+  const context = buildFilterContext(state, schema, meter);
   const resultBitset = evaluateFilters(filters, context);
   const resolver = state.docStore.resolver();
   const externalResult = /* @__PURE__ */ new Set();
@@ -3385,12 +3499,12 @@ function applyPartitionFilters(state, filters, schema) {
   }
   return externalResult;
 }
-function applyPartitionFiltersBitset(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
+function applyPartitionFiltersBitset(state, filters, schema, meter) {
+  const context = buildFilterContext(state, schema, meter);
   return evaluateFilters(filters, context);
 }
-function partitionFilterMatches(state, filters, schema) {
-  const accepted = applyPartitionFiltersBitset(state, filters, schema);
+function partitionFilterMatches(state, filters, schema, meter) {
+  const accepted = applyPartitionFiltersBitset(state, filters, schema, meter);
   const docStore = state.docStore;
   const resolver = docStore.resolver();
   let count = 0;
@@ -3547,6 +3661,8 @@ function estimatePartitionBytes(state) {
   bytes += docCount * state.booleanIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
   bytes += docCount * state.enumIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
   bytes += docCount * state.geoIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.sizeIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  for (const index of state.patternIndexes.values()) bytes += index.bytes();
   return bytes + sortColumnBytes(state);
 }
 
@@ -3606,12 +3722,12 @@ function mergeSurfaceForms(target, source) {
     target.surfaceRegistry.add(surface, value[1], value[0]);
   }
 }
-function mergeFieldIndexes(target, source, idMapping) {
-  for (const [fieldPath, index] of source.numericIndexes) {
-    let targetIndex = target.numericIndexes.get(fieldPath);
+function mergeNumericIndexes(target, source, idMapping) {
+  for (const [fieldPath, index] of source) {
+    let targetIndex = target.get(fieldPath);
     if (targetIndex === void 0) {
       targetIndex = createNumericIndex();
-      target.numericIndexes.set(fieldPath, targetIndex);
+      target.set(fieldPath, targetIndex);
     }
     for (const entry of index.serialize()) {
       const targetInternalId = idMapping.get(entry.docId);
@@ -3619,6 +3735,10 @@ function mergeFieldIndexes(target, source, idMapping) {
       targetIndex.insert(targetInternalId, entry.value);
     }
   }
+}
+function mergeFieldIndexes(target, source, idMapping) {
+  mergeNumericIndexes(target.numericIndexes, source.numericIndexes, idMapping);
+  mergeNumericIndexes(target.sizeIndexes, source.sizeIndexes, idMapping);
   for (const [fieldPath, index] of source.booleanIndexes) {
     let targetIndex = target.booleanIndexes.get(fieldPath);
     if (targetIndex === void 0) {
@@ -3660,6 +3780,12 @@ function mergeFieldIndexes(target, source, idMapping) {
       targetIndex.insert(targetInternalId, entry.lat, entry.lon);
     }
   }
+  for (const [fieldPath, index] of source.patternIndexes) {
+    patternIndexOf(target.patternIndexes, fieldPath).addArrays(
+      index.toArrays(fieldPath, null),
+      (sourceInternalId) => idMapping.get(sourceInternalId) ?? -1
+    );
+  }
 }
 function mergeSegmentState(target, source) {
   if (source.stats.totalDocuments === 0 && source.docStore.count() === 0) return;
@@ -4680,19 +4806,23 @@ function searchFulltext(state, params) {
 }
 
 // src/core/partition/segment-field-indexes.ts
-function encodeFieldIndexes(state, remap) {
-  const survives = (internalId) => remap[internalId] >= 0;
-  const numeric = [];
-  for (const [fieldPath, index] of state.numericIndexes) {
-    const entries = index.serialize().filter((entry) => survives(entry.docId));
+function encodeNumericIndexes(indexes, remap) {
+  const encoded = [];
+  for (const [fieldPath, index] of indexes) {
+    const entries = index.serialize().filter((entry) => remap[entry.docId] >= 0);
     const docIds = new Uint32Array(entries.length);
     const values = new Float64Array(entries.length);
     for (let i = 0; i < entries.length; i++) {
       docIds[i] = remap[entries[i].docId];
       values[i] = entries[i].value;
     }
-    numeric.push({ fieldPath, docIds, values });
+    encoded.push({ fieldPath, docIds, values });
   }
+  return encoded;
+}
+function encodeFieldIndexes(state, remap) {
+  const survives = (internalId) => remap[internalId] >= 0;
+  const numeric = encodeNumericIndexes(state.numericIndexes, remap);
   const booleans = [];
   for (const [fieldPath, index] of state.booleanIndexes) {
     const { trueDocs, falseDocs } = index.serialize();
@@ -4733,7 +4863,9 @@ function encodeFieldIndexes(state, remap) {
     }
     geo.push({ fieldPath, docIds, latitudes, longitudes });
   }
-  return { numeric, boolean: booleans, enums, geo };
+  const pattern = [];
+  for (const [fieldPath, index] of state.patternIndexes) pattern.push(index.toArrays(fieldPath, remap));
+  return { numeric, boolean: booleans, enums, geo, pattern, sizes: encodeNumericIndexes(state.sizeIndexes, remap) };
 }
 
 // src/core/partition/segment-payload.ts
@@ -4890,15 +5022,19 @@ function mergePayloadPostings(target, payload, ordinalBase) {
     }
   }
 }
-function mergePayloadFieldIndexes(target, payload, ordinalBase) {
-  for (const entry of payload.numeric) {
-    let index = target.numericIndexes.get(entry.fieldPath);
+function mergePayloadNumericIndexes(target, entries, ordinalBase) {
+  for (const entry of entries) {
+    let index = target.get(entry.fieldPath);
     if (index === void 0) {
       index = createNumericIndex();
-      target.numericIndexes.set(entry.fieldPath, index);
+      target.set(entry.fieldPath, index);
     }
     for (let i = 0; i < entry.docIds.length; i++) index.insert(ordinalBase + entry.docIds[i], entry.values[i]);
   }
+}
+function mergePayloadFieldIndexes(target, payload, ordinalBase) {
+  mergePayloadNumericIndexes(target.numericIndexes, payload.numeric, ordinalBase);
+  mergePayloadNumericIndexes(target.sizeIndexes, payload.sizes, ordinalBase);
   for (const entry of payload.boolean) {
     let index = target.booleanIndexes.get(entry.fieldPath);
     if (index === void 0) {
@@ -4929,6 +5065,9 @@ function mergePayloadFieldIndexes(target, payload, ordinalBase) {
       index.insert(ordinalBase + entry.docIds[i], entry.latitudes[i], entry.longitudes[i]);
     }
   }
+  for (const entry of payload.pattern) {
+    patternIndexOf(target.patternIndexes, entry.fieldPath).addArrays(entry, (ordinal) => ordinalBase + ordinal);
+  }
 }
 function mergeSegmentPayload(target, payload, documents) {
   if (payload.documentCount === 0) return;
@@ -4973,6 +5112,123 @@ function mergeSegmentPayload(target, payload, documents) {
   target.scoreBuffer = null;
 }
 
+// src/core/partition/pattern-snapshot.ts
+function loadFailed(fieldPath, problem) {
+  return new NarsilError(
+    ErrorCodes.PERSISTENCE_LOAD_FAILED,
+    `The pattern index of field "${fieldPath}" in this partition is corrupt: ${problem}`,
+    { field: fieldPath }
+  );
+}
+function serializePatternIndex(state, fieldPath, index) {
+  const resolver = state.docStore.resolver();
+  const arrays = index.toArrays(fieldPath, null);
+  const positionOf = /* @__PURE__ */ new Map();
+  const docIds = [];
+  for (const ordinal of arrays.docIds) {
+    const externalId = resolver.toExternal(ordinal);
+    if (externalId === void 0) continue;
+    positionOf.set(ordinal, docIds.length);
+    docIds.push(externalId);
+  }
+  const runs = /* @__PURE__ */ Object.create(null);
+  for (let run = 0; run + 1 < arrays.offsets.length; run++) {
+    const positions = [];
+    for (let at = arrays.offsets[run]; at < arrays.offsets[run + 1]; at++) {
+      const position = positionOf.get(arrays.postings[at]);
+      if (position !== void 0) positions.push(position);
+    }
+    if (positions.length === 0) continue;
+    const base = run * PATTERN_RUN_CODE_POINTS;
+    runs[String.fromCodePoint(arrays.runs[base], arrays.runs[base + 1], arrays.runs[base + 2])] = positions;
+  }
+  return { docIds, runs };
+}
+function serializePatternIndexes(state, schema) {
+  const patternFields = schemaFieldsOf(schema).filter((field) => field.pattern);
+  if (patternFields.length === 0) return void 0;
+  const serialized = /* @__PURE__ */ Object.create(null);
+  for (const { path: fieldPath } of patternFields) {
+    const index = state.patternIndexes.get(fieldPath);
+    serialized[fieldPath] = index === void 0 ? { docIds: [], runs: {} } : serializePatternIndex(state, fieldPath, index);
+  }
+  return serialized;
+}
+function appendRunCodePoints(fieldPath, key, out) {
+  const start = out.length;
+  for (const character of key) out.push(character.codePointAt(0) ?? 0);
+  const count = out.length - start;
+  if (count !== PATTERN_RUN_CODE_POINTS) {
+    throw loadFailed(
+      fieldPath,
+      `the key "${key}" holds ${count} code points, while each key must hold ${PATTERN_RUN_CODE_POINTS}`
+    );
+  }
+}
+function requirePositions(fieldPath, key, list, documentCount) {
+  if (!Array.isArray(list)) throw loadFailed(fieldPath, `the run "${key}" must map to a list of positions`);
+  let previous = -1;
+  for (const position of list) {
+    if (!Number.isInteger(position) || position < 0 || position >= documentCount) {
+      throw loadFailed(fieldPath, `the run "${key}" names position ${String(position)} outside its document list`);
+    }
+    if (position <= previous) {
+      throw loadFailed(fieldPath, `the positions of the run "${key}" are out of ascending order`);
+    }
+    previous = position;
+  }
+  return list;
+}
+function requireDistinctDocuments(fieldPath, docIds) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    if (seen.has(docId)) throw loadFailed(fieldPath, `the document list names "${docId}" twice`);
+    seen.add(docId);
+  }
+}
+function decodePatternEntry(fieldPath, entry) {
+  requireDistinctDocuments(fieldPath, entry.docIds);
+  const runs = [];
+  const offsets = [0];
+  const postings = [];
+  for (const [key, list] of Object.entries(entry.runs)) {
+    appendRunCodePoints(fieldPath, key, runs);
+    for (const position of requirePositions(fieldPath, key, list, entry.docIds.length)) postings.push(position);
+    offsets.push(postings.length);
+  }
+  const positions = new Uint32Array(entry.docIds.length);
+  for (let position = 0; position < positions.length; position++) positions[position] = position;
+  return {
+    fieldPath,
+    docIds: positions,
+    runs: Uint32Array.from(runs),
+    offsets: Uint32Array.from(offsets),
+    postings: Uint32Array.from(postings)
+  };
+}
+function rebuildPatternIndex(state, fieldPath) {
+  for (const [docId, stored] of state.docStore.all()) {
+    const value = getNestedValue(stored.fields, fieldPath);
+    if (value === void 0 || value === null) continue;
+    const internalId = state.docStore.getInternalId(docId);
+    if (internalId !== void 0) patternIndexOf(state.patternIndexes, fieldPath).add(internalId, value);
+  }
+}
+function loadPatternIndexes(state, serialized, schema) {
+  const resolver = state.docStore.resolver();
+  for (const { path: fieldPath, pattern } of schemaFieldsOf(schema)) {
+    if (!pattern) continue;
+    const entry = serialized !== void 0 && Object.hasOwn(serialized, fieldPath) ? serialized[fieldPath] : void 0;
+    if (entry === void 0) {
+      rebuildPatternIndex(state, fieldPath);
+      continue;
+    }
+    const decoded = decodePatternEntry(fieldPath, entry);
+    const ordinals = entry.docIds.map((docId) => resolver.toInternal(docId) ?? -1);
+    patternIndexOf(state.patternIndexes, fieldPath).addArrays(decoded, (position) => ordinals[position]);
+  }
+}
+
 // src/core/partition/serialization.ts
 function serializePartition(state, partitionId, indexName, totalPartitions, language, schema) {
   const flatSchema = getFlatSchema(state, schema);
@@ -5045,6 +5301,7 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
     }));
   }
   const serializedStats = state.stats.serialize();
+  const serializedPattern = serializePatternIndexes(state, schema);
   return {
     indexName,
     partitionId,
@@ -5059,7 +5316,8 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
       numeric: serializedNumeric,
       boolean: serializedBoolean,
       enum: serializedEnum,
-      geopoint: serializedGeo
+      geopoint: serializedGeo,
+      ...serializedPattern === void 0 ? {} : { pattern: serializedPattern }
     },
     surfaceForms: state.surfaceRegistry.serialize(),
     statistics: serializedStats
@@ -5137,6 +5395,8 @@ function deserializePartition(state, data, clearFn, schema) {
       throw new Error(`Schema mismatch: serialized data contains unknown field "${field}" not present in schema`);
     }
   }
+  loadPatternIndexes(state, data.fieldIndexes.pattern, schema);
+  rebuildSizeIndexes(state, schema);
 }
 
 // src/core/partition/suggestions.ts
@@ -5299,7 +5559,8 @@ function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalP
       numeric: wireNumeric,
       boolean: wireBoolean,
       enum: wireEnum,
-      geopoint: wireGeo
+      geopoint: wireGeo,
+      ...patternIndexesToWire(serializePatternIndexes(state, schema))
     },
     surface_forms: state.surfaceRegistry.serialize(),
     statistics: {
@@ -5334,6 +5595,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     booleanIndexes: /* @__PURE__ */ new Map(),
     enumIndexes: /* @__PURE__ */ new Map(),
     geoIndexes: /* @__PURE__ */ new Map(),
+    patternIndexes: /* @__PURE__ */ new Map(),
+    sizeIndexes: /* @__PURE__ */ new Map(),
     fieldNameTable,
     flatSchemaCache: null,
     lastSchemaRef: null,
@@ -5353,6 +5616,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     state.booleanIndexes.clear();
     state.enumIndexes.clear();
     state.geoIndexes.clear();
+    state.patternIndexes.clear();
+    state.sizeIndexes.clear();
     state.stats.deserialize({ totalDocuments: 0, totalFieldLengths: {}, averageFieldLengths: {}, docFrequencies: {} });
     state.flatSchemaCache = null;
     state.lastSchemaRef = null;
@@ -5528,14 +5793,14 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     sortValues(docId, fields, fieldTypes, modes) {
       return sortValuesOf(state, docId, fields, fieldTypes, modes);
     },
-    applyFilters(filters, schema) {
-      return applyPartitionFilters(state, filters, schema);
+    applyFilters(filters, schema, meter) {
+      return applyPartitionFilters(state, filters, schema, meter);
     },
-    applyFiltersBitset(filters, schema) {
-      return applyPartitionFiltersBitset(state, filters, schema);
+    applyFiltersBitset(filters, schema, meter) {
+      return applyPartitionFiltersBitset(state, filters, schema, meter);
     },
-    filterMatches(filters, schema) {
-      return partitionFilterMatches(state, filters, schema);
+    filterMatches(filters, schema, meter) {
+      return partitionFilterMatches(state, filters, schema, meter);
     },
     computeFacets(matched, config, schema) {
       return computeFacets(state, matched, config, schema);
@@ -5575,12 +5840,13 @@ function frozenSegmentBytes(segment) {
     bytes += arrays.documentTable.blob.byteLength + arrays.documentTable.offsets.byteLength;
   }
   for (const column of arrays.fieldLengthColumns) bytes += column.byteLength;
-  for (const entry of arrays.numeric) bytes += entry.docIds.byteLength + entry.values.byteLength;
+  for (const entry of [...arrays.numeric, ...arrays.sizes]) bytes += entry.docIds.byteLength + entry.values.byteLength;
   for (const entry of arrays.boolean) bytes += entry.trueDocs.byteLength + entry.falseDocs.byteLength;
   for (const entry of arrays.enums) bytes += entry.offsets.byteLength + entry.docIds.byteLength;
   for (const entry of arrays.geo) {
     bytes += entry.docIds.byteLength + entry.latitudes.byteLength + entry.longitudes.byteLength;
   }
+  for (const reader of segment.patternIndexes.values()) bytes += reader.bytes();
   return bytes;
 }
 
@@ -5658,24 +5924,24 @@ function placeSubBitset(composite, layout, subIndex, subBits) {
   if (words === 0) return;
   composite.set(subBits.length > words ? subBits.subarray(0, words) : subBits, layout.bases[subIndex] >> 5);
 }
-function compositeFiltersBitset(subs, layout, filters, schema) {
+function compositeFiltersBitset(subs, layout, filters, schema, meter) {
   const composite = new Uint32Array(Math.ceil(layout.totalCapacity / WORD_BITS));
   for (let i = 0; i < subs.length; i++) {
-    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema));
+    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema, meter));
   }
   return composite;
 }
-function compositeFilters(subs, filters, schema) {
+function compositeFilters(subs, filters, schema, meter) {
   const combined = /* @__PURE__ */ new Set();
   for (const sub of subs) {
-    for (const docId of applyPartitionFilters(sub, filters, schema)) {
+    for (const docId of applyPartitionFilters(sub, filters, schema, meter)) {
       combined.add(docId);
     }
   }
   return combined;
 }
-function compositeFilterMatches(subs, layout, filters, schema) {
-  const bits = compositeFiltersBitset(subs, layout, filters, schema);
+function compositeFilterMatches(subs, layout, filters, schema, meter) {
+  const bits = compositeFiltersBitset(subs, layout, filters, schema, meter);
   let count = 0;
   for (let i = 0; i < subs.length; i++) {
     const resolver = subs[i].docStore.resolver();
@@ -6136,14 +6402,14 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
     searchFulltextMatches(params) {
       return compositeSearchMatches(subs(), layout(), params);
     },
-    applyFilters(filters, schema) {
-      return compositeFilters(subs(), filters, schema);
+    applyFilters(filters, schema, meter) {
+      return compositeFilters(subs(), filters, schema, meter);
     },
-    applyFiltersBitset(filters, schema) {
-      return compositeFiltersBitset(subs(), layout(), filters, schema);
+    applyFiltersBitset(filters, schema, meter) {
+      return compositeFiltersBitset(subs(), layout(), filters, schema, meter);
     },
-    filterMatches(filters, schema) {
-      return compositeFilterMatches(subs(), layout(), filters, schema);
+    filterMatches(filters, schema, meter) {
+      return compositeFilterMatches(subs(), layout(), filters, schema, meter);
     },
     computeFacets(matched, config, schema) {
       const everyValue = everyValueFacetConfig(config);
@@ -6294,6 +6560,7 @@ function createCapacityChecks(source) {
 
 // src/partitioning/manager/index.ts
 function createPartitionManager(indexName, config, language, router, initialPartitionCount, vectorIndexes) {
+  requirePatternSearchFor(config.schema);
   const count = initialPartitionCount ?? 1;
   const analysis = resolveIndexAnalysis(config);
   const trackPositions = config.trackPositions ?? true;
@@ -9346,7 +9613,22 @@ function createFrozenEnumReader(entry) {
   function rangeOf(value) {
     return rangeByValue.get(value) ?? { from: 0, to: 0 };
   }
+  let affixes = null;
+  function affixesOf() {
+    affixes ??= new ValueAffixes(() => true, values);
+    return affixes;
+  }
+  function bitsetOfValues(matching, capacity) {
+    const bits = createBitSet(capacity);
+    for (const value of matching) {
+      const { from, to } = rangeOf(value);
+      for (let i = from; i < to; i++) bitsetSet(bits, docIds[i]);
+    }
+    return bits;
+  }
   return {
+    queryPrefixBitset: (prefix, capacity) => bitsetOfValues(affixesOf().withPrefix(prefix), capacity),
+    querySuffixBitset: (suffix, capacity) => bitsetOfValues(affixesOf().withSuffix(suffix), capacity),
     serialize: () => {
       const byValue = /* @__PURE__ */ Object.create(null);
       for (let i = 0; i < values.length; i++) {
@@ -9791,6 +10073,11 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
       docIds: sharedUint32(entry.docIds),
       values: sharedFloat64(entry.values)
     })),
+    sizes: payload.sizes.map((entry) => ({
+      fieldPath: entry.fieldPath,
+      docIds: sharedUint32(entry.docIds),
+      values: sharedFloat64(entry.values)
+    })),
     boolean: payload.boolean.map((entry) => ({
       fieldPath: entry.fieldPath,
       trueDocs: sharedUint32(entry.trueDocs),
@@ -9808,6 +10095,13 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
       latitudes: sharedFloat64(entry.latitudes),
       longitudes: sharedFloat64(entry.longitudes)
     })),
+    pattern: payload.pattern.map((entry) => ({
+      fieldPath: entry.fieldPath,
+      docIds: sharedUint32(entry.docIds),
+      runs: sharedUint32(entry.runs),
+      offsets: sharedUint32(entry.offsets),
+      postings: sharedUint32(entry.postings)
+    })),
     surfaceTable: sharedSurfaceTable(payload)
   };
 }
@@ -9854,10 +10148,16 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
   const docStore = createFrozenDocTable(source.idTable, lengthColumns, documentSource, tombstones);
   const numericIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.numeric) numericIndexes.set(entry.fieldPath, createFrozenNumericReader(entry));
+  const sizeIndexes = /* @__PURE__ */ new Map();
+  for (const entry of source.sizes) sizeIndexes.set(entry.fieldPath, createFrozenNumericReader(entry));
   const booleanIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.boolean) booleanIndexes.set(entry.fieldPath, createFrozenBooleanReader(entry));
   const enumIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.enums) enumIndexes.set(entry.fieldPath, createFrozenEnumReader(entry));
+  const patternIndexes = /* @__PURE__ */ new Map();
+  for (const entry of source.pattern) {
+    patternIndexes.set(entry.fieldPath, requirePatternSearch(entry.fieldPath).readArrays(entry));
+  }
   const fieldNameTable = {
     names: [...source.fieldNames],
     indexMap: new Map(source.fieldNames.map((name, index) => [name, index]))
@@ -9875,6 +10175,8 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     booleanIndexes,
     enumIndexes,
     geoIndexes: buildGeoReaders(source.geo),
+    patternIndexes,
+    sizeIndexes,
     fieldNameTable,
     trackPositions: source.positionOffsets !== null,
     flatSchemaCache: null,
@@ -10002,12 +10304,8 @@ function remapDocIds(inputs, pick) {
   }
   return out;
 }
-function mergeNumeric(inputs) {
-  const byFieldPath = rowsByFieldPath(
-    inputs,
-    (input) => input.segment.arrays.numeric,
-    (entry, at) => [entry.values[at]]
-  );
+function mergeNumeric(inputs, pick) {
+  const byFieldPath = rowsByFieldPath(inputs, pick, (entry, at) => [entry.values[at]]);
   const merged = [];
   for (const [fieldPath, rows] of byFieldPath) {
     rows.sort((a, b) => a.values[0] - b.values[0] || a.docId - b.docId);
@@ -10080,12 +10378,32 @@ function mergeEnums(inputs) {
   }
   return merged;
 }
+function mergePattern(inputs) {
+  const byFieldPath = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    for (const arrays of input.segment.arrays.pattern) {
+      let entries = byFieldPath.get(arrays.fieldPath);
+      if (entries === void 0) {
+        entries = [];
+        byFieldPath.set(arrays.fieldPath, entries);
+      }
+      entries.push({ arrays, remap: input.remap });
+    }
+  }
+  const merged = [];
+  for (const [fieldPath, entries] of byFieldPath) {
+    merged.push(requirePatternSearch(fieldPath).mergeArrays(fieldPath, entries));
+  }
+  return merged;
+}
 function mergeFieldIndexes2(inputs) {
   return {
-    numeric: mergeNumeric(inputs),
+    numeric: mergeNumeric(inputs, (input) => input.segment.arrays.numeric),
     boolean: mergeBoolean(inputs),
     enums: mergeEnums(inputs),
-    geo: mergeGeo(inputs)
+    geo: mergeGeo(inputs),
+    pattern: mergePattern(inputs),
+    sizes: mergeNumeric(inputs, (input) => input.segment.arrays.sizes)
   };
 }
 
@@ -10397,84 +10715,7 @@ function mergeFrozenSegments(segments) {
   return freezeEncodedSegmentShared(payload, mergeDocuments2(inputs, documentCount));
 }
 
-// src/core/partition/growable-uint32.ts
-var GrowableUint32 = class {
-  values;
-  length = 0;
-  constructor(capacity) {
-    this.values = new Uint32Array(capacity);
-  }
-  growTo(needed, kept) {
-    let capacity = this.values.length * 2;
-    while (capacity < needed) capacity *= 2;
-    const next = new Uint32Array(capacity);
-    next.set(this.values.subarray(0, kept));
-    this.values = next;
-  }
-  reserve(extra) {
-    const needed = this.length + extra;
-    if (needed > this.values.length) this.growTo(needed, this.length);
-  }
-  push(value) {
-    if (this.length === this.values.length) this.growTo(this.length + 1, this.length);
-    this.values[this.length++] = value;
-  }
-  ensureIndex(index) {
-    if (index >= this.values.length) this.growTo(index + 1, this.values.length);
-  }
-  clear() {
-    this.length = 0;
-  }
-};
-
-// src/core/partition/segment-builder.ts
-var TOKEN_TABLE_START = 1 << 12;
-var POSTING_LOG_START = 1 << 14;
-var POSITION_POOL_START = 1 << 16;
-var FIELD_SCRATCH_START = 1 << 10;
-function indexOf(indexes, fieldPath, create) {
-  let index = indexes.get(fieldPath);
-  if (index === void 0) {
-    index = create();
-    indexes.set(fieldPath, index);
-  }
-  return index;
-}
-function indexFilterValue(indexes, ordinal, fieldPath, fieldType, value) {
-  if (fieldType === "number" || fieldType === "number[]") {
-    const index = indexOf(indexes.numericIndexes, fieldPath, createNumericIndex);
-    for (const entry of fieldType === "number" ? [value] : value) index.insert(ordinal, entry);
-  } else if (fieldType === "boolean" || fieldType === "boolean[]") {
-    const index = indexOf(indexes.booleanIndexes, fieldPath, createBooleanIndex);
-    for (const entry of fieldType === "boolean" ? [value] : value)
-      index.insert(ordinal, entry);
-  } else if (fieldType === "enum" || fieldType === "enum[]") {
-    const index = indexOf(indexes.enumIndexes, fieldPath, createEnumIndex);
-    for (const entry of fieldType === "enum" ? [value] : value) index.insert(ordinal, entry);
-  } else if (fieldType === "geopoint") {
-    const point = value;
-    indexOf(indexes.geoIndexes, fieldPath, createGeoIndex).insert(ordinal, point.lat, point.lon);
-  }
-}
-function refuseRepeatedDocIds(documents) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const { docId } of documents) {
-    if (seen.has(docId)) {
-      throw new NarsilError(ErrorCodes.DOC_ALREADY_EXISTS, `Document "${docId}" already exists in partition 0`, {
-        docId,
-        partitionId: 0
-      });
-    }
-    seen.add(docId);
-  }
-}
-function validateAsAnInsertDoes(documents, schema, options) {
-  if (options?.validate === false) return;
-  for (const { document } of documents) {
-    validateDocument(document, schema, options?.patternValueLimit);
-    if (options?.strict) validateDocumentStrict(document, schema);
-  }
-}
+// src/core/partition/segment-postings.ts
 var TextPostings = class {
   constructor(trackPositions) {
     this.trackPositions = trackPositions;
@@ -10483,22 +10724,22 @@ var TextPostings = class {
   fieldNames = [];
   tokenIds = /* @__PURE__ */ new Map();
   fieldNameIndexes = /* @__PURE__ */ new Map();
-  postingsPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  docFrequencyPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  lastDocPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  fieldStampPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  fieldSlotPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  logToken = new GrowableUint32(POSTING_LOG_START);
-  logDoc = new GrowableUint32(POSTING_LOG_START);
-  logFrequency = new GrowableUint32(POSTING_LOG_START);
-  logField = new GrowableUint32(POSTING_LOG_START);
-  logPositionStart = new GrowableUint32(POSTING_LOG_START);
-  positionPool = new GrowableUint32(POSITION_POOL_START);
-  slotToken = new GrowableUint32(FIELD_SCRATCH_START);
-  slotCount = new GrowableUint32(FIELD_SCRATCH_START);
-  slotCursor = new GrowableUint32(FIELD_SCRATCH_START);
-  eventSlot = new GrowableUint32(FIELD_SCRATCH_START);
-  eventPosition = new GrowableUint32(FIELD_SCRATCH_START);
+  postingsPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  docFrequencyPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  lastDocPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  fieldStampPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  fieldSlotPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  logToken = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logDoc = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logFrequency = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logField = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logPositionStart = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  positionPool = new GrowableUint32(SEGMENT_POSITION_POOL_START);
+  slotToken = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  slotCount = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  slotCursor = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  eventSlot = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  eventPosition = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
   fieldStamp = 0;
   beginField() {
     this.fieldStamp++;
@@ -10626,11 +10867,56 @@ var TextPostings = class {
     };
   }
 };
+
+// src/core/partition/segment-builder.ts
+function indexOf(indexes, fieldPath, create) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = create();
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+function indexFilterValue(indexes, ordinal, fieldPath, fieldType, value) {
+  if (fieldType === "number" || fieldType === "number[]") {
+    const index = indexOf(indexes.numericIndexes, fieldPath, createNumericIndex);
+    for (const entry of fieldType === "number" ? [value] : value) index.insert(ordinal, entry);
+  } else if (fieldType === "boolean" || fieldType === "boolean[]") {
+    const index = indexOf(indexes.booleanIndexes, fieldPath, createBooleanIndex);
+    for (const entry of fieldType === "boolean" ? [value] : value)
+      index.insert(ordinal, entry);
+  } else if (fieldType === "enum" || fieldType === "enum[]") {
+    const index = indexOf(indexes.enumIndexes, fieldPath, createEnumIndex);
+    for (const entry of fieldType === "enum" ? [value] : value) index.insert(ordinal, entry);
+  } else if (fieldType === "geopoint") {
+    const point = value;
+    indexOf(indexes.geoIndexes, fieldPath, createGeoIndex).insert(ordinal, point.lat, point.lon);
+  }
+}
+function refuseRepeatedDocIds(documents) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const { docId } of documents) {
+    if (seen.has(docId)) {
+      throw new NarsilError(ErrorCodes.DOC_ALREADY_EXISTS, `Document "${docId}" already exists in partition 0`, {
+        docId,
+        partitionId: 0
+      });
+    }
+    seen.add(docId);
+  }
+}
+function validateAsAnInsertDoes(documents, schema, options) {
+  if (options?.validate === false) return;
+  for (const { document } of documents) {
+    validateDocument(document, schema, options?.patternValueLimit);
+    if (options?.strict) validateDocumentStrict(document, schema);
+  }
+}
 var SurfaceCounts = class {
   ids = /* @__PURE__ */ new Map();
   surfaces = [];
   tokens = [];
-  counts = new GrowableUint32(TOKEN_TABLE_START);
+  counts = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
   count(surface, token) {
     if (surface === void 0 || surface.length === 0) return;
     const known = this.ids.get(surface);
@@ -10690,7 +10976,9 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
     numericIndexes: /* @__PURE__ */ new Map(),
     booleanIndexes: /* @__PURE__ */ new Map(),
     enumIndexes: /* @__PURE__ */ new Map(),
-    geoIndexes: /* @__PURE__ */ new Map()
+    geoIndexes: /* @__PURE__ */ new Map(),
+    patternIndexes: /* @__PURE__ */ new Map(),
+    sizeIndexes: /* @__PURE__ */ new Map()
   };
   let positionOffset = 0;
   const addToken = (token, position, surface) => {
@@ -10699,9 +10987,11 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
   };
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
     const document = documents[ordinal].document;
-    for (const { path: fieldPath, base: fieldType } of fields) {
+    for (const { path: fieldPath, base: fieldType, pattern } of fields) {
       const value = getNestedValue(document, fieldPath);
       if (value === void 0 || value === null) continue;
+      recordValueSize(filters.sizeIndexes, ordinal, fieldPath, fieldType, value);
+      if (pattern) patternIndexOf(filters.patternIndexes, fieldPath).add(ordinal, value);
       if (!isWordIndexedBase(fieldType)) {
         indexFilterValue(filters, ordinal, fieldPath, fieldType, value);
         continue;
@@ -11152,6 +11442,7 @@ function createDirectExecutor(options) {
       }
       case "query": {
         const entry = requireIndex(action.indexName);
+        const patternWork = joinPatternWorkMeter(action.patternWork);
         const result = await fanOutQuery(
           entry.manager,
           action.params,
@@ -11162,15 +11453,17 @@ function createDirectExecutor(options) {
             partitionIds: action.partitionIds,
             ...action.globalStats !== void 0 ? { globalStats: sanitizeGlobalStats(action.globalStats) } : {}
           },
-          entry.searchOptions
+          { ...entry.searchOptions, patternWork }
         );
+        result.patternWorkSpent = patternWork.spent();
         return result;
       }
       case "preflight": {
         const entry = requireIndex(action.indexName);
+        const searchOptions = { ...entry.searchOptions, patternWork: joinPatternWorkMeter(action.patternWork) };
         if (countsWithoutScores(action.params)) {
           const count = fanOutMatchCount(entry.manager, action.params, entry.language, entry.config.schema, {
-            searchOptions: entry.searchOptions
+            searchOptions
           });
           return { count };
         }
@@ -11180,7 +11473,7 @@ function createDirectExecutor(options) {
           entry.language,
           entry.config.schema,
           { scoringMode: entry.config.defaultScoring ?? "local" },
-          entry.searchOptions
+          searchOptions
         );
         return { count: result.totalMatched };
       }
@@ -11266,4 +11559,4 @@ function createDirectExecutor(options) {
   };
 }
 
-export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };
+export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };