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

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

@@ -1,14 +1,15 @@
-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 { 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 { getLanguage, detectRuntime } from './chunk-4MQ5F4IL.mjs';
+import { tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, everyValueFacetConfig, mergeFacets, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-3YKWSO54.mjs';
+import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, MAX_DOC_ID_LENGTH, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-AK3BLGCI.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, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, requireWholeNeighbourLists, topLayerInParts, 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-WVDFG45M.mjs';
+import { MAX_M, noteFallback, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-PU43WDY4.mjs';
+import { GrowableUint32, patternSearchModule } from './chunk-XW25X6AU.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, defaultSortMode, compareComparableValues, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
-import { encode, decode } from '@msgpack/msgpack';
+import { decode } from '@msgpack/msgpack';
 
 var MEGABYTE_BYTES = 1048576;
 var IN_MEGABYTES = /^--max-old-space-size=(\d+)$/;
@@ -116,478 +117,6 @@ function resolveIndexAnalysis(config) {
     customTokenizer: typeof config.tokenizer === "string" ? getTokenizer(config.tokenizer) : config.tokenizer
   };
 }
-function metadataToWire(meta) {
-  const wire = {
-    index_name: meta.indexName,
-    schema: meta.schema,
-    language: meta.language,
-    partition_count: meta.partitionCount,
-    bm25_params: meta.bm25Params,
-    created_at: meta.createdAt,
-    engine_version: meta.engineVersion
-  };
-  if (meta.vectorFields) {
-    wire.vector_fields = meta.vectorFields;
-  }
-  if (isNonNegativeInteger(meta.documentCount) && Number.isSafeInteger(meta.documentCount)) {
-    wire.document_count = meta.documentCount;
-  }
-  if (meta.embedding) {
-    wire.embedding = meta.embedding.adapter !== void 0 ? { adapter: meta.embedding.adapter, fields: meta.embedding.fields } : { fields: meta.embedding.fields };
-  }
-  if (meta.surfaceForms !== void 0) {
-    wire.surface_forms_enabled = meta.surfaceForms;
-  }
-  if (meta.analysisRevision !== void 0) {
-    wire.analysis_revision = meta.analysisRevision;
-  }
-  if (meta.tokenizer !== void 0) {
-    wire.tokenizer = meta.tokenizer;
-  }
-  if (meta.stopWords !== void 0) {
-    wire.stop_words = meta.stopWords;
-  }
-  if (meta.stopWordList !== void 0) {
-    wire.stop_word_list = meta.stopWordList;
-  }
-  if (meta.partitionLimits !== void 0) {
-    wire.partition_limits = {
-      ...meta.partitionLimits.maxDocsPerPartition !== void 0 ? { max_docs_per_partition: meta.partitionLimits.maxDocsPerPartition } : {},
-      ...meta.partitionLimits.maxPartitions !== void 0 ? { max_partitions: meta.partitionLimits.maxPartitions } : {},
-      ...meta.partitionLimits.watermark !== void 0 ? { watermark: meta.partitionLimits.watermark } : {}
-    };
-  }
-  if (meta.defaultScoring !== void 0) {
-    wire.default_scoring = meta.defaultScoring;
-  }
-  if (meta.trackPositions !== void 0) {
-    wire.track_positions = meta.trackPositions;
-  }
-  if (meta.strict !== void 0) {
-    wire.strict = meta.strict;
-  }
-  if (meta.required !== void 0) {
-    wire.required = meta.required;
-  }
-  if (meta.vectorPromotion !== void 0) {
-    const promotion = meta.vectorPromotion;
-    wire.vector_promotion = {
-      ...promotion.threshold !== void 0 ? { threshold: promotion.threshold } : {},
-      ...promotion.filterThreshold !== void 0 ? { filter_threshold: promotion.filterThreshold } : {},
-      ...promotion.hnswConfig !== void 0 ? {
-        hnsw_config: {
-          ...promotion.hnswConfig.m !== void 0 ? { m: promotion.hnswConfig.m } : {},
-          ...promotion.hnswConfig.efConstruction !== void 0 ? { ef_construction: promotion.hnswConfig.efConstruction } : {},
-          ...promotion.hnswConfig.metric !== void 0 ? { metric: promotion.hnswConfig.metric } : {}
-        }
-      } : {},
-      ...promotion.quantization !== void 0 ? { quantization: promotion.quantization } : {},
-      ...promotion.storage !== void 0 ? { storage: promotion.storage } : {}
-    };
-  }
-  if (meta.patternValueLimit !== void 0) {
-    wire.pattern_value_limit = meta.patternValueLimit;
-  }
-  if (meta.indexUuid !== void 0) {
-    wire.index_uuid = meta.indexUuid;
-  }
-  if (meta.heldPartitions !== void 0) {
-    wire.held_partitions = meta.heldPartitions;
-  }
-  return wire;
-}
-function wireToMetadata(raw) {
-  const meta = {
-    indexName: raw.index_name,
-    schema: raw.schema ?? {},
-    language: raw.language ?? "english",
-    partitionCount: raw.partition_count ?? 1,
-    bm25Params: raw.bm25_params ?? { k1: 1.2, b: 0.75 },
-    createdAt: raw.created_at ?? 0,
-    engineVersion: raw.engine_version ?? "0.0.0"
-  };
-  if (raw.vector_fields) {
-    for (const [fieldPath, field] of Object.entries(raw.vector_fields)) {
-      if (!isQuantizationMode(field.quantization)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector quantization "${String(field.quantization)}" for "${fieldPath}" this engine does not read`,
-          { fieldPath, quantization: field.quantization }
-        );
-      }
-    }
-    meta.vectorFields = raw.vector_fields;
-  }
-  if (isNonNegativeInteger(raw.document_count) && Number.isSafeInteger(raw.document_count)) {
-    meta.documentCount = raw.document_count;
-  }
-  if (raw.embedding && typeof raw.embedding === "object" && typeof raw.embedding.fields === "object") {
-    meta.embedding = typeof raw.embedding.adapter === "string" ? { adapter: raw.embedding.adapter, fields: raw.embedding.fields } : { fields: raw.embedding.fields };
-  }
-  if (typeof raw.surface_forms_enabled === "boolean") {
-    meta.surfaceForms = raw.surface_forms_enabled;
-  }
-  if (typeof raw.analysis_revision === "string") {
-    meta.analysisRevision = raw.analysis_revision;
-  }
-  if (typeof raw.tokenizer === "string") {
-    meta.tokenizer = raw.tokenizer;
-  }
-  if (typeof raw.stop_words === "string") {
-    meta.stopWords = raw.stop_words;
-  }
-  if (Array.isArray(raw.stop_word_list) && raw.stop_word_list.every((word) => typeof word === "string")) {
-    meta.stopWordList = raw.stop_word_list;
-  }
-  if (raw.partition_limits && typeof raw.partition_limits === "object") {
-    const limits = {
-      ...isPositiveInteger(raw.partition_limits.max_docs_per_partition) ? { maxDocsPerPartition: raw.partition_limits.max_docs_per_partition } : {},
-      ...isPositiveInteger(raw.partition_limits.max_partitions) ? { maxPartitions: raw.partition_limits.max_partitions } : {},
-      ...isWatermarkFraction(raw.partition_limits.watermark) ? { watermark: raw.partition_limits.watermark } : {}
-    };
-    if (Object.keys(limits).length > 0) {
-      meta.partitionLimits = limits;
-    }
-  }
-  if (raw.default_scoring === "local" || raw.default_scoring === "dfs" || raw.default_scoring === "broadcast") {
-    meta.defaultScoring = raw.default_scoring;
-  }
-  if (typeof raw.track_positions === "boolean") {
-    meta.trackPositions = raw.track_positions;
-  }
-  if (typeof raw.strict === "boolean") {
-    meta.strict = raw.strict;
-  }
-  if (Array.isArray(raw.required) && raw.required.every((field) => typeof field === "string")) {
-    meta.required = raw.required;
-  }
-  if (raw.vector_promotion && typeof raw.vector_promotion === "object") {
-    const promotion = raw.vector_promotion;
-    const hnsw = promotion.hnsw_config && typeof promotion.hnsw_config === "object" ? promotion.hnsw_config : void 0;
-    const metric = hnsw?.metric;
-    const restored = {};
-    const hnswConfig = {};
-    if (isPositiveInteger(hnsw?.m)) {
-      hnswConfig.m = hnsw?.m;
-    }
-    if (isPositiveInteger(hnsw?.ef_construction)) {
-      hnswConfig.efConstruction = hnsw?.ef_construction;
-    }
-    if (metric === "cosine" || metric === "dotProduct" || metric === "euclidean") {
-      hnswConfig.metric = metric;
-    }
-    if (isPositiveInteger(promotion.threshold)) {
-      restored.threshold = promotion.threshold;
-    }
-    if (isSelectivityRatio(promotion.filter_threshold)) {
-      restored.filterThreshold = promotion.filter_threshold;
-    }
-    if (Object.keys(hnswConfig).length > 0) {
-      restored.hnswConfig = hnswConfig;
-    }
-    if (promotion.quantization !== void 0) {
-      if (!isQuantizationMode(promotion.quantization)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector quantization "${String(promotion.quantization)}" this engine does not read`,
-          { quantization: promotion.quantization }
-        );
-      }
-      restored.quantization = promotion.quantization;
-    }
-    if (promotion.storage !== void 0) {
-      if (!isStorageMode(promotion.storage)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector storage "${String(promotion.storage)}" this engine does not read`,
-          { storage: promotion.storage }
-        );
-      }
-      restored.storage = promotion.storage;
-    }
-    if (Object.keys(restored).length > 0) {
-      meta.vectorPromotion = restored;
-    }
-  }
-  if (raw.pattern_value_limit !== void 0) {
-    if (!isPositiveInteger(raw.pattern_value_limit)) {
-      throw new NarsilError(
-        ErrorCodes.CONFIG_INVALID,
-        `The pattern value limit in the index metadata is ${String(raw.pattern_value_limit)}, but the limit must be a whole number of code points`,
-        { patternValueLimit: String(raw.pattern_value_limit) }
-      );
-    }
-    meta.patternValueLimit = raw.pattern_value_limit;
-  }
-  if (typeof raw.index_uuid === "string" && raw.index_uuid.length > 0) {
-    meta.indexUuid = raw.index_uuid;
-  }
-  if (Array.isArray(raw.held_partitions) && raw.held_partitions.every(isNonNegativeInteger)) {
-    meta.heldPartitions = raw.held_partitions;
-  }
-  return meta;
-}
-function isNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-function isPositiveInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 1;
-}
-function isSelectivityRatio(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
-}
-function isWatermarkFraction(value) {
-  return typeof value === "number" && value > 0 && value <= 1;
-}
-function serializeMetadata(meta) {
-  const wire = metadataToWire(meta);
-  return encode(wire);
-}
-function deserializeMetadata(data) {
-  const raw = decode(data);
-  return wireToMetadata(raw);
-}
-
-// src/serialization/stored-vector-values.ts
-function dropStoredVectorValues(documents, schema) {
-  const vectorFieldPaths = [];
-  for (const [fieldPath, fieldType] of Object.entries(schema)) {
-    if (typeof fieldType === "string" && VECTOR_PATTERN.test(fieldType)) {
-      vectorFieldPaths.push(fieldPath);
-    }
-  }
-  if (vectorFieldPaths.length === 0) {
-    return;
-  }
-  for (const document of Object.values(documents)) {
-    for (const fieldPath of vectorFieldPaths) {
-      removeFieldAtPath(document.fields, fieldPath);
-    }
-  }
-}
-function removeFieldAtPath(fields, fieldPath) {
-  if (!fieldPath.includes(".")) {
-    delete fields[fieldPath];
-    return;
-  }
-  const segments = fieldPath.split(".");
-  let current = fields;
-  for (let i = 0; i < segments.length - 1; i += 1) {
-    const next = current[segments[i]];
-    if (next === null || typeof next !== "object") {
-      return;
-    }
-    current = next;
-  }
-  delete current[segments[segments.length - 1]];
-}
-
-// src/serialization/payload-v1/partition.ts
-function sanitizeSurfaceForms(raw) {
-  if (raw === void 0 || raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const result = /* @__PURE__ */ Object.create(null);
-  let count = 0;
-  for (const [surface, value] of Object.entries(raw)) {
-    if (typeof value === "number") {
-      result[surface] = value;
-      count++;
-    } else if (Array.isArray(value) && typeof value[0] === "number" && typeof value[1] === "string") {
-      result[surface] = [value[0], value[1]];
-      count++;
-    }
-  }
-  return count > 0 ? result : void 0;
-}
-function validateHnswMetric(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
-    return value;
-  }
-  return void 0;
-}
-function wireToPartition(raw) {
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  requireValidFieldTypes(raw.schema ?? {});
-  dropStoredVectorValues(documents, raw.schema ?? {});
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
-    invertedIndex[token] = {
-      docFrequency: list.doc_freq,
-      postings: (list.postings ?? []).map((p) => ({
-        docId: p.doc_id,
-        termFrequency: p.term_freq,
-        field: p.field,
-        positions: p.positions ?? []
-      }))
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data.dimension,
-      vectors: (data.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data.hnsw_graph ? {
-        entryPoint: data.hnsw_graph.entry_point,
-        maxLayer: data.hnsw_graph.max_layer,
-        m: data.hnsw_graph.m,
-        efConstruction: data.hnsw_graph.ef_construction,
-        metric: validateHnswMetric(data.hnsw_graph.metric),
-        nodes: data.hnsw_graph.nodes
-      } : null,
-      codes: data.codes ? { bits: data.codes.bits, centroid: data.codes.centroid, records: data.codes.records } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint
-    },
-    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
-function deserializePayloadV1(data) {
-  const raw = decode(data);
-  return wireToPartition(raw);
-}
-
-// src/serialization/payload-v2.ts
-function encodeRawPayloadV2(wire) {
-  return encode(wire);
-}
-function validateHnswMetric2(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
-    return value;
-  }
-  return void 0;
-}
-function storedDocumentsOf(raw) {
-  requireValidFieldTypes(raw.schema ?? {});
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  dropStoredVectorValues(documents, raw.schema ?? {});
-  return documents;
-}
-function documentsOfPayloadV2(data) {
-  const raw = decode(data);
-  return { documents: storedDocumentsOf(raw), schema: raw.schema ?? {} };
-}
-function deserializePayloadV2(data) {
-  const raw = decode(data);
-  const documents = storedDocumentsOf(raw);
-  const fieldNames = raw.inverted_index?.field_names ?? [];
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index?.entries ?? {})) {
-    const count = list.ids.length;
-    const postings = new Array(count);
-    for (let i = 0; i < count; i++) {
-      postings[i] = {
-        docId: list.ids[i],
-        termFrequency: list.tf[i],
-        field: fieldNames[list.fi[i]] ?? "",
-        positions: list.pos ? list.pos[i] : []
-      };
-    }
-    invertedIndex[token] = {
-      docFrequency: list.df,
-      postings
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data2] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data2.dimension,
-      vectors: (data2.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data2.hnsw_graph ? {
-        entryPoint: data2.hnsw_graph.entry_point,
-        maxLayer: data2.hnsw_graph.max_layer,
-        m: data2.hnsw_graph.m,
-        efConstruction: data2.hnsw_graph.ef_construction,
-        metric: validateHnswMetric2(data2.hnsw_graph.metric),
-        nodes: data2.hnsw_graph.nodes
-      } : null,
-      codes: data2.codes ? { bits: data2.codes.bits, centroid: data2.codes.centroid, records: data2.codes.records } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint
-    },
-    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
 
 // src/core/document-store.ts
 function detachedView(view) {
@@ -847,7 +376,7 @@ function createPostingList() {
     length: 0,
     docIds: [],
     termFrequencies: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
-    fieldNameIndices: new Uint8Array(POSTING_LIST_INITIAL_CAPACITY),
+    fieldNameIndices: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
     positions: null,
     docIdSet: /* @__PURE__ */ new Set(),
     deletedDocs: /* @__PURE__ */ new Set(),
@@ -861,7 +390,7 @@ function growTypedArrays(list) {
   const newTF = new Uint16Array(newCap);
   newTF.set(list.termFrequencies);
   list.termFrequencies = newTF;
-  const newFNI = new Uint8Array(newCap);
+  const newFNI = new Uint16Array(newCap);
   newFNI.set(list.fieldNameIndices);
   list.fieldNameIndices = newFNI;
 }
@@ -1106,7 +635,7 @@ function createInvertedIndex(fieldNameTable) {
         const docIdSet = /* @__PURE__ */ new Set();
         const docIds = new Array(count);
         const termFrequencies = new Uint16Array(count);
-        const fieldNameIndices = new Uint8Array(count);
+        const fieldNameIndices = new Uint16Array(count);
         let hasPositions = false;
         let validCount = 0;
         let totalTermFrequency = 0;
@@ -1411,8 +940,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 +1051,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 +1212,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 +1309,7 @@ function createEnumIndex() {
       if (!docSet) {
         docSet = /* @__PURE__ */ new Set();
         valueMap.set(value, docSet);
+        affixes?.add(value);
       }
       docSet.add(internalId);
     },
@@ -1626,7 +1317,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 +1401,7 @@ function createEnumIndex() {
     },
     clear() {
       valueMap.clear();
+      affixes = null;
     },
     serialize() {
       const result = /* @__PURE__ */ Object.create(null);
@@ -1712,6 +1412,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 +1594,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 +1770,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 +1819,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 +1895,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,277 +1974,248 @@ 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]);
-  }
-  return result;
-}
-function applyOrBitset(bitsets) {
-  if (bitsets.length === 0) return new Uint32Array(0);
-  if (bitsets.length === 1) return bitsets[0];
-  let result = bitsets[0];
-  for (let i = 1; i < bitsets.length; i++) {
-    result = bitsetOr(result, bitsets[i]);
-  }
-  return result;
-}
-function applyNotBitset(excluded, capacity) {
-  return bitsetNot(excluded, capacity);
-}
-
-// src/filters/keys.ts
-var FILTER_EXPRESSION_KEYS = ["fields", "and", "or", "not"];
-var FIELD_FILTER_OPERATORS = [
-  "eq",
-  "ne",
-  "gt",
-  "lt",
-  "gte",
-  "lte",
-  "between",
-  "in",
-  "nin",
-  "startsWith",
-  "endsWith",
-  "containsAll",
-  "matchesAny",
-  "size",
-  "exists",
-  "notExists",
-  "isEmpty",
-  "isNotEmpty",
-  "radius",
-  "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/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/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);
+// 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;
   }
-  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));
+  none() {
+    return createBitSet(this.context.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);
+  present() {
+    return this.context.presentBitset(this.fieldPath);
   }
-  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);
+  holdingSomething() {
+    const empty = this.context.sizeIndex(this.fieldPath)?.queryEqBitset(0, this.context.capacity);
+    return empty === void 0 ? this.present() : this.without(this.present(), empty);
   }
-  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);
+  without(from, removed) {
+    const kept = from.slice();
+    bitsetAndNotInto(kept, removed);
+    return kept;
   }
-  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);
+  complement(bits) {
+    return this.without(this.context.allDocIdsBitset, bits);
   }
-  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);
+};
+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;
   }
-  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);
+  if (parsed.base === "enum[]") {
+    return context.enumIndex(fieldPath)?.queryInBitset(values, capacity) ?? union;
   }
-  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 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);
   }
-  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);
+  return union;
 }
-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 distinctScalars(values) {
+  return [...new Set(values)];
 }
-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 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 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 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 applyGeoPolygonBitset(filter, geoIndex, capacity) {
-  requirePolygonRing(filter.points);
-  const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
-  return bitsetFromSet(setResult, 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);
+  }
 }
-
-// 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 { lower: bound, upper: null, lowerInclusive: operator === "gte", upperInclusive: false };
   }
-  return { ...UNBOUNDED, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
+  return { lower: null, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
 }
-var TEXT_RANGE_OPERATORS = ["gt", "gte", "lt", "lte"];
+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
+var FILTER_EXPRESSION_KEYS = ["fields", "and", "or", "not"];
+var FIELD_FILTER_OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "lt",
+  "gte",
+  "lte",
+  "between",
+  "in",
+  "nin",
+  "startsWith",
+  "endsWith",
+  "contains",
+  "caseFold",
+  "containsAll",
+  "matchesAny",
+  "size",
+  "exists",
+  "notExists",
+  "isEmpty",
+  "isNotEmpty",
+  "radius",
+  "polygon"
+];
+
+// src/filters/evaluator.ts
 var EXPRESSION_KEYS = new Set(FILTER_EXPRESSION_KEYS);
 var OPERATOR_KEYS = new Set(FIELD_FILTER_OPERATORS);
 function requireKnownKeys(value, known, describe) {
@@ -2503,160 +2225,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)
-    );
-  }
-  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 }
-    );
+    const kept = context.allDocIdsBitset.slice();
+    bitsetAndNotInto(kept, excluded);
+    narrowing.narrow(kept);
   }
-  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 +2901,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 +2986,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 +3148,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 +3209,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 +3222,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 +3267,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 +4293,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 +4350,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
@@ -4799,7 +4418,7 @@ function encodeSegmentState(state) {
   const postingOffsets = new Uint32Array(state.invertedIdx.size() + 1);
   const postingDocIds = new Uint32Array(postings);
   const postingFrequencies = new Uint16Array(postings);
-  const postingFieldIndices = new Uint8Array(postings);
+  const postingFieldIndices = new Uint16Array(postings);
   const positionOffsets = hasPositions ? new Uint32Array(postings + 1) : null;
   const positionValues = hasPositions ? new Uint32Array(positions) : null;
   let postingCursor = 0;
@@ -4890,15 +4509,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 +4552,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 +4599,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 +4788,7 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
     }));
   }
   const serializedStats = state.stats.serialize();
+  const serializedPattern = serializePatternIndexes(state, schema);
   return {
     indexName,
     partitionId,
@@ -5059,7 +4803,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 +4882,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
@@ -5175,140 +4922,34 @@ function suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit) {
     }
   }
   const results = [];
-  for (const [token, group] of groups) {
-    results.push({ token, documentFrequency: group.documentFrequency, surfaces: group.surfaces });
-  }
-  results.sort((a, b) => b.documentFrequency - a.documentFrequency || compareCodePoints(a.token, b.token));
-  if (results.length > limit) results.length = limit;
-  return results;
-}
-function expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions) {
-  if (maxExpansions <= 0 || surfacePrefix.length === 0) return [];
-  const dfByToken = /* @__PURE__ */ new Map();
-  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
-    if (dfByToken.has(candidate.token)) continue;
-    const postingList = state.invertedIdx.lookup(candidate.token);
-    if (!postingList || postingList.docIdSet.size === 0) continue;
-    dfByToken.set(candidate.token, postingList.docIdSet.size);
-  }
-  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedToken !== surfacePrefix && stemmedToken.length > 0 ? [surfacePrefix, stemmedToken] : [surfacePrefix];
-  for (const prefix of termPrefixes) {
-    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
-      if (dfByToken.has(suggestion.term)) continue;
-      if (verbatimOccurrences(state, suggestion.term) === 0) continue;
-      dfByToken.set(suggestion.term, suggestion.documentFrequency);
-    }
-  }
-  const entries = Array.from(dfByToken.entries());
-  entries.sort((a, b) => b[1] - a[1] || compareCodePoints(a[0], b[0]));
-  if (entries.length > maxExpansions) entries.length = maxExpansions;
-  return entries.map((e) => e[0]);
-}
-
-// src/core/partition/wire-payload.ts
-function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalPartitions, language, schema) {
-  const flatSchema = getFlatSchema(state, schema);
-  const flatSchemaStrings = {};
-  for (const [k, v] of Object.entries(flatSchema)) {
-    flatSchemaStrings[k] = v;
-  }
-  const wireDocs = /* @__PURE__ */ Object.create(null);
-  for (const [docId, stored] of state.docStore.all()) {
-    wireDocs[docId] = {
-      fields: stored.fields,
-      field_lengths: { ...stored.fieldLengths }
-    };
-  }
-  const resolver = state.docStore.resolver();
-  const fieldNames = [...state.fieldNameTable.names];
-  const wireEntries = /* @__PURE__ */ Object.create(null);
-  for (const token of state.invertedIdx.tokens()) {
-    const list = state.invertedIdx.lookup(token);
-    if (!list) continue;
-    const hasDeleted = list.deletedDocs.size > 0;
-    const ids = [];
-    const tf = [];
-    const fi = new Uint8Array(list.length);
-    const pos = list.positions ? [] : null;
-    let writeIdx = 0;
-    for (let i = 0; i < list.length; i++) {
-      if (hasDeleted && list.deletedDocs.has(list.docIds[i])) continue;
-      const externalId = resolver.toExternal(list.docIds[i]);
-      if (externalId === void 0) continue;
-      ids.push(externalId);
-      tf.push(list.termFrequencies[i]);
-      fi[writeIdx] = list.fieldNameIndices[i];
-      writeIdx++;
-      if (pos && list.positions) {
-        pos.push(list.positions[i]);
-      }
-    }
-    if (ids.length > 0) {
-      const finalFi = writeIdx < list.length ? fi.subarray(0, writeIdx) : fi;
-      wireEntries[token] = { df: list.docIdSet.size, ids, tf, fi: finalFi, pos };
-    }
-  }
-  const wireNumeric = {};
-  for (const [path, idx] of state.numericIndexes) {
-    wireNumeric[path] = idx.serialize().map((e) => ({
-      value: e.value,
-      doc_id: resolver.toExternal(e.docId) ?? ""
-    }));
-  }
-  const wireBoolean = {};
-  for (const [path, idx] of state.booleanIndexes) {
-    const s = idx.serialize();
-    wireBoolean[path] = {
-      true_docs: s.trueDocs.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== ""),
-      false_docs: s.falseDocs.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== "")
-    };
-  }
-  const wireEnum = {};
-  for (const [path, idx] of state.enumIndexes) {
-    const raw = idx.serialize();
-    const converted = /* @__PURE__ */ Object.create(null);
-    for (const [value, internalIds] of Object.entries(raw)) {
-      converted[value] = internalIds.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== "");
-    }
-    wireEnum[path] = converted;
+  for (const [token, group] of groups) {
+    results.push({ token, documentFrequency: group.documentFrequency, surfaces: group.surfaces });
   }
-  const wireGeo = {};
-  for (const [path, idx] of state.geoIndexes) {
-    wireGeo[path] = idx.serialize().map((e) => ({
-      lat: e.lat,
-      lon: e.lon,
-      doc_id: resolver.toExternal(e.docId) ?? ""
-    }));
+  results.sort((a, b) => b.documentFrequency - a.documentFrequency || compareCodePoints(a.token, b.token));
+  if (results.length > limit) results.length = limit;
+  return results;
+}
+function expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions) {
+  if (maxExpansions <= 0 || surfacePrefix.length === 0) return [];
+  const dfByToken = /* @__PURE__ */ new Map();
+  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
+    if (dfByToken.has(candidate.token)) continue;
+    const postingList = state.invertedIdx.lookup(candidate.token);
+    if (!postingList || postingList.docIdSet.size === 0) continue;
+    dfByToken.set(candidate.token, postingList.docIdSet.size);
   }
-  const serializedStats = state.stats.serialize();
-  return {
-    v: 2,
-    index_name: indexName,
-    partition_id: partitionId,
-    total_partitions: totalPartitions,
-    language,
-    schema: flatSchemaStrings,
-    doc_count: state.docStore.count(),
-    avg_doc_length: Object.values(serializedStats.averageFieldLengths).reduce((sum, v) => sum + v, 0),
-    documents: wireDocs,
-    inverted_index: {
-      field_names: fieldNames,
-      entries: wireEntries
-    },
-    field_indexes: {
-      numeric: wireNumeric,
-      boolean: wireBoolean,
-      enum: wireEnum,
-      geopoint: wireGeo
-    },
-    surface_forms: state.surfaceRegistry.serialize(),
-    statistics: {
-      total_documents: serializedStats.totalDocuments,
-      total_field_lengths: serializedStats.totalFieldLengths,
-      average_field_lengths: serializedStats.averageFieldLengths,
-      doc_frequencies: serializedStats.docFrequencies
+  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedToken !== surfacePrefix && stemmedToken.length > 0 ? [surfacePrefix, stemmedToken] : [surfacePrefix];
+  for (const prefix of termPrefixes) {
+    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
+      if (dfByToken.has(suggestion.term)) continue;
+      if (verbatimOccurrences(state, suggestion.term) === 0) continue;
+      dfByToken.set(suggestion.term, suggestion.documentFrequency);
     }
-  };
+  }
+  const entries = Array.from(dfByToken.entries());
+  entries.sort((a, b) => b[1] - a[1] || compareCodePoints(a[0], b[0]));
+  if (entries.length > maxExpansions) entries.length = maxExpansions;
+  return entries.map((e) => e[0]);
 }
 
 // src/core/partition/index.ts
@@ -5334,6 +4975,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 +4996,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 +5173,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);
@@ -5549,10 +5194,6 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     serialize(indexName, totalPartitions, language, schema) {
       return serializePartition(state, partitionId, indexName, totalPartitions, language, schema);
     },
-    serializeToBytes(indexName, totalPartitions, language, schema) {
-      const wire = serializePartitionToWirePayloadV2(state, partitionId, indexName, totalPartitions, language, schema);
-      return encodeRawPayloadV2(wire);
-    },
     deserialize(data, schema) {
       deserializePartition(state, data, clearAll, schema);
     }
@@ -5575,12 +5216,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 +5300,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();
@@ -6074,10 +5716,6 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       if (frozen.length === 0) return live.serialize(indexName, totalPartitions, language, schema);
       return composedScratch().serialize(indexName, totalPartitions, language, schema);
     },
-    serializeToBytes(indexName, totalPartitions, language, schema) {
-      if (frozen.length === 0) return live.serializeToBytes(indexName, totalPartitions, language, schema);
-      return composedScratch().serializeToBytes(indexName, totalPartitions, language, schema);
-    },
     deserialize(data, schema) {
       frozen.length = 0;
       invalidateDocFrequencies();
@@ -6136,14 +5774,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 +5932,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;
@@ -6507,10 +6146,6 @@ function createPartitionManager(indexName, config, language, router, initialPart
       validatePartitionId(partitionId);
       return partitions[partitionId].serialize(indexName, partitions.length, language.name, config.schema);
     },
-    serializePartitionToBytes(partitionId) {
-      validatePartitionId(partitionId);
-      return partitions[partitionId].serializeToBytes(indexName, partitions.length, language.name, config.schema);
-    },
     mergeSegment(partitionId, payload, documents) {
       validatePartitionId(partitionId);
       const partition = partitions[partitionId];
@@ -6636,6 +6271,9 @@ var WORKER_COPY_MIN_VECTORS = 1024;
 var BUILD_CHUNK_SIZE = 100;
 var REBUILD_REMOVED_RATIO = 0.2;
 var VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE = 0.2;
+var VECTOR_FILE_FIXED_OVERHEAD_BYTES = 65536;
+var VECTOR_FILE_STRING_HEADER_BYTES = 5;
+var VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT = 9;
 var OSQ4_MIN_DIMENSION = 384;
 var DISK_ADOPTION_YIELD_INTERVAL = 4096;
 
@@ -6695,7 +6333,7 @@ function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 function* allLiveDocIds(state) {
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     yield docId;
   }
@@ -6816,14 +6454,6 @@ async function nodeThreadId() {
     return 0;
   }
 }
-async function isNodeMainThread() {
-  try {
-    const workerThreads = await import('worker_threads');
-    return workerThreads.isMainThread;
-  } catch {
-    return true;
-  }
-}
 
 // src/workers/entry-point.ts
 var DIST_SEGMENT = "/dist/";
@@ -7588,6 +7218,12 @@ function scheduleBuild(state) {
   }, 0);
 }
 
+// src/serialization/constants.ts
+var CHECKSUM_YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
+var NATIVE_CRC32_MIN_BYTES = 16;
+var MAX_FILE_BYTES = 2147483647;
+var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
+
 // src/vector/vector-index/payload.ts
 var VECTOR_INDEX_PAYLOAD_VERSION = 3;
 var VECTOR_INDEX_PART_VECTORS = 65536;
@@ -7614,7 +7250,7 @@ function invalid(message, details) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNonNegativeInteger2(value) {
+function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 function isSerializedGraph(value) {
@@ -7644,9 +7280,9 @@ function decodeVectorIndexPart(raw) {
     );
   }
   if (typeof raw.fieldName !== "string") invalid("fieldName must be a string");
-  if (!isNonNegativeInteger2(raw.dimension) || raw.dimension === 0) invalid("dimension must be a positive integer");
-  if (!isNonNegativeInteger2(raw.part)) invalid("part must be a non-negative integer");
-  if (!isNonNegativeInteger2(raw.parts) || raw.parts === 0 || raw.part >= raw.parts) {
+  if (!isNonNegativeInteger(raw.dimension) || raw.dimension === 0) invalid("dimension must be a positive integer");
+  if (!isNonNegativeInteger(raw.part)) invalid("part must be a non-negative integer");
+  if (!isNonNegativeInteger(raw.parts) || raw.parts === 0 || raw.part >= raw.parts) {
     invalid("parts must exceed part", { part: raw.part, parts: raw.parts });
   }
   if (!Array.isArray(raw.docIds) || !raw.docIds.every((docId) => typeof docId === "string")) {
@@ -7685,6 +7321,8 @@ function decodeVectorIndexParts(raw) {
 // src/vector/vector-index/checkpoint-payload.ts
 var VECTOR_FILE_PAYLOAD_VERSION = 1;
 var VECTOR_GRAPH_PAYLOAD_VERSION = 1;
+var VECTOR_GRAPH_PART_PAYLOAD_VERSION = 2;
+var VECTOR_GRAPH_PART_VECTORS = 16384;
 var VECTOR_FILE_MAX_VECTORS = VECTOR_INDEX_PART_VECTORS;
 var METRICS = ["cosine", "dotProduct", "euclidean"];
 function invalid2(payload, message, details) {
@@ -7735,14 +7373,16 @@ function decodeVectorFilePayload(raw) {
 function isMetric(value) {
   return METRICS.some((metric) => metric === value);
 }
-function decodeNumberedGraph(raw) {
+function decodeNumberedGraph(raw, minimumM) {
   const name = "vector graph";
   if (!isRecord2(raw)) invalid2(name, "each graph must be a map");
   const entryPoint = raw.entryPoint ?? null;
   if (entryPoint !== null && !isIntegerUpTo(entryPoint, 4294967295))
     invalid2(name, "entryPoint must be a uint32 or nil");
   if (!isIntegerUpTo(raw.maxLayer, 255)) invalid2(name, "maxLayer must be a uint8");
-  if (!isIntegerUpTo(raw.m, 65535) || raw.m === 0) invalid2(name, "m must be a positive uint16");
+  if (!isIntegerUpTo(raw.m, MAX_M) || raw.m < minimumM) {
+    invalid2(name, `m must be a whole number from ${minimumM} to ${MAX_M}`);
+  }
   if (!isIntegerUpTo(raw.efConstruction, 65535)) invalid2(name, "efConstruction must be a uint16");
   if (!isMetric(raw.metric)) invalid2(name, "metric must name a supported metric", { metric: raw.metric });
   if (!(raw.levels instanceof Uint8Array)) invalid2(name, "levels must be bytes");
@@ -7763,7 +7403,56 @@ function decodeVectorGraphPayload(raw) {
   requireVersion(name, raw.v, VECTOR_GRAPH_PAYLOAD_VERSION);
   if (typeof raw.fieldName !== "string") invalid2(name, "fieldName must be a string");
   if (!Array.isArray(raw.graphs)) invalid2(name, "graphs must be a list");
-  return { v: VECTOR_GRAPH_PAYLOAD_VERSION, fieldName: raw.fieldName, graphs: raw.graphs.map(decodeNumberedGraph) };
+  return {
+    v: VECTOR_GRAPH_PAYLOAD_VERSION,
+    fieldName: raw.fieldName,
+    graphs: raw.graphs.map((graph) => decodeNumberedGraph(graph, EARLIER_RELEASE_MIN_M))
+  };
+}
+function decodeVectorGraphPartPayload(raw) {
+  const name = "vector graph part";
+  if (!isRecord2(raw)) invalid2(name, "payload must be a map");
+  requireVersion(name, raw.v, VECTOR_GRAPH_PART_PAYLOAD_VERSION);
+  if (typeof raw.fieldName !== "string") invalid2(name, "fieldName must be a string");
+  if (!Array.isArray(raw.graphs)) invalid2(name, "graphs must be a list");
+  return {
+    v: VECTOR_GRAPH_PART_PAYLOAD_VERSION,
+    fieldName: raw.fieldName,
+    graphs: raw.graphs.map((graph) => decodeNumberedGraph(graph, MIN_M))
+  };
+}
+function sameGraphHeader(a, b) {
+  return a.entryPoint === b.entryPoint && a.maxLayer === b.maxLayer && a.m === b.m && a.efConstruction === b.efConstruction && a.metric === b.metric;
+}
+function assembleGraphParts(parts) {
+  const name = "vector graph part";
+  const first = parts[0];
+  if (first === void 0) invalid2(name, "a field that holds a graph must have at least one part");
+  const partLists = first.graphs.map(() => []);
+  for (let p = 0; p < parts.length; p++) {
+    const part = parts[p];
+    const isLast = p === parts.length - 1;
+    if (part.fieldName !== first.fieldName || part.graphs.length !== first.graphs.length) {
+      invalid2(name, `part ${p} lists other graphs than part 0`, { part: p });
+    }
+    for (let g = 0; g < part.graphs.length; g++) {
+      const graph = part.graphs[g];
+      if (!sameGraphHeader(graph, first.graphs[g]))
+        invalid2(name, `part ${p} gives graph ${g} other headers`, { part: p });
+      const levels = graph.levels.length;
+      const fits = isLast ? levels >= 1 && levels <= VECTOR_GRAPH_PART_VECTORS : levels === VECTOR_GRAPH_PART_VECTORS;
+      if (!fits) invalid2(name, `part ${p} gives graph ${g} ${levels} bytes of levels`, { part: p, levels });
+      partLists[g].push(graph);
+    }
+  }
+  const graphs = partLists.map((list) => ({ partSize: VECTOR_GRAPH_PART_VECTORS, parts: list }));
+  return { fieldName: first.fieldName, graphs };
+}
+function graphPartsOfEarlierPayload(payload) {
+  return {
+    fieldName: payload.fieldName,
+    graphs: payload.graphs.map((graph) => ({ partSize: Math.max(graph.levels.length, 1), parts: [graph] }))
+  };
 }
 
 // src/vector/vector-index/dead-bits.ts
@@ -7793,36 +7482,6 @@ function deadBitsWhere(count, isDeadAt) {
 }
 
 // src/vector/vector-index/persistence.ts
-function liveDocIds(state) {
-  const docIds = [];
-  for (let ordinal = 0; ordinal < state.store.slots; ordinal++) {
-    const docId = state.store.docIdForOrdinal(ordinal);
-    if (docId === void 0 || state.tombstones.has(docId)) continue;
-    docIds.push(docId);
-  }
-  return docIds;
-}
-function partVectors(state, docIds) {
-  const dimension = state.dimension;
-  const vectors = new Float32Array(docIds.length * dimension);
-  for (let i = 0; i < docIds.length; i++) {
-    const entry = state.store.get(docIds[i]);
-    if (entry !== void 0) vectors.set(entry.vector, i * dimension);
-  }
-  return vectors;
-}
-function graphsPerPart(state, partOf, parts) {
-  const sliced = Array.from({ length: parts }, () => []);
-  if (state.hnsw === null || partOf.size === 0) return sliced;
-  const graph = state.hnsw.serialize();
-  const nodesPerPart = Array.from({ length: parts }, () => []);
-  for (const node of graph.nodes) {
-    const part = partOf.get(node[0]);
-    if (part !== void 0) nodesPerPart[part].push(node);
-  }
-  for (let part = 0; part < parts; part++) sliced[part].push({ ...graph, nodes: nodesPerPart[part] });
-  return sliced;
-}
 function recordFor(state, quantizer, docId) {
   const record = quantizer.recordOf(docId);
   if (record !== void 0) return record;
@@ -7861,36 +7520,6 @@ function partCodes(state, docIds, centroid) {
   }
   return { bits: quantizer.bits, centroid, records };
 }
-function planParts(state) {
-  const docIds = liveDocIds(state);
-  const parts = Math.max(1, Math.ceil(docIds.length / VECTOR_INDEX_PART_VECTORS));
-  const partOf = /* @__PURE__ */ new Map();
-  for (let i = 0; i < docIds.length; i++) partOf.set(docIds[i], Math.floor(i / VECTOR_INDEX_PART_VECTORS));
-  const graphs = graphsPerPart(state, partOf, parts);
-  const centroid = codedCentroid(state);
-  return {
-    parts,
-    readPart(part) {
-      const start = part * VECTOR_INDEX_PART_VECTORS;
-      const slice = docIds.slice(start, start + VECTOR_INDEX_PART_VECTORS);
-      return {
-        v: VECTOR_INDEX_PAYLOAD_VERSION,
-        fieldName: state.fieldName,
-        dimension: state.dimension,
-        part,
-        parts,
-        docIds: slice,
-        graphs: graphs[part],
-        codes: partCodes(state, slice, centroid),
-        vectors: vectorsToBytes(partVectors(state, slice))
-      };
-    }
-  };
-}
-function serialize(state) {
-  const plan = planParts(state);
-  return Array.from({ length: plan.parts }, (_, part) => plan.readPart(part));
-}
 function splitSequences(parts) {
   const sequences = [];
   let current = null;
@@ -7943,7 +7572,7 @@ function restoreCodes(state, sequences) {
 }
 function restoreGraphs(state, graphs) {
   if (graphs.length === 0) {
-    for (const [docId] of state.store.entries()) {
+    for (const docId of state.store.docIds()) {
       if (!state.tombstones.has(docId)) state.buffer.add(docId);
     }
     return;
@@ -7966,14 +7595,14 @@ function restoreGraphs(state, graphs) {
       if (!restoredHnsw.has(nodeDocId) && state.store.has(nodeDocId)) restoredHnsw.insertNode(nodeDocId);
     }
   }
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     if (!restoredHnsw.has(docId)) state.buffer.add(docId);
   }
   if (state.buffer.size > restoredHnsw.size) {
     adoptGraph(state, null);
     state.buffer.clear();
-    for (const [docId] of state.store.entries()) {
+    for (const docId of state.store.docIds()) {
       if (!state.tombstones.has(docId)) state.buffer.add(docId);
     }
   }
@@ -8012,6 +7641,17 @@ function deserialize(state, parts) {
 
 // src/vector/vector-index/checkpoint-plan.ts
 var ORDINAL_HOLDS_NO_NUMBER = -1;
+function vectorsPerFile(dimension, codeBits) {
+  const recordBytes = codeBits === 1 || codeBits === 2 || codeBits === 4 || codeBits === 8 ? osqRecordBytes(dimension, codeBits) : 0;
+  const docIdBytes = VECTOR_FILE_STRING_HEADER_BYTES + MAX_DOC_ID_LENGTH * 3;
+  const perVector = dimension * 4 + recordBytes + docIdBytes;
+  const overhead = VECTOR_FILE_FIXED_OVERHEAD_BYTES + dimension * VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT;
+  const fitting = Math.floor((MAX_FILE_BYTES - overhead) / perVector);
+  return Math.max(1, Math.min(VECTOR_FILE_MAX_VECTORS, fitting));
+}
+function fileCapacityOf(state) {
+  return vectorsPerFile(state.dimension, osqBitsOf(state.quantizationMode));
+}
 function calibrationOf(state) {
   if (codedCentroid(state) === null) return null;
   return Atomics.load(state.store.handles.header, STORE_CALIBRATION_GENERATION);
@@ -8051,10 +7691,10 @@ function filesWorthKeeping(state, listed, calibration, liveCounts) {
   }
   return kept;
 }
-function absorbSmallerPartialFiles(kept, liveCounts, vectorsToWrite) {
+function absorbSmallerPartialFiles(kept, liveCounts, vectorsToWrite, capacity) {
   let pending = vectorsToWrite;
   for (let index = kept.length - 1; index >= 0 && pending > 0; index--) {
-    if (kept[index].ordinals.length >= VECTOR_FILE_MAX_VECTORS) continue;
+    if (kept[index].ordinals.length >= capacity) continue;
     if (liveCounts[index] > pending) return;
     pending += liveCounts[index];
     kept.splice(index, 1);
@@ -8102,13 +7742,14 @@ function numberEveryVector(state, kept, written) {
   }
   return { numberOfOrdinal, ordinalOfNumber };
 }
-function graphOf(state, numbers) {
-  if (state.hnsw === null) return null;
-  return {
-    v: VECTOR_GRAPH_PAYLOAD_VERSION,
-    fieldName: state.fieldName,
-    graphs: [state.hnsw.serializeNumbered(numbers.numberOfOrdinal, numbers.ordinalOfNumber)]
-  };
+function graphPartsOf(state, numbers) {
+  if (state.hnsw === null || numbers.ordinalOfNumber.length === 0) return null;
+  const parts = state.hnsw.serializeNumbered(
+    numbers.numberOfOrdinal,
+    numbers.ordinalOfNumber,
+    VECTOR_GRAPH_PART_VECTORS
+  );
+  return parts.map((graph) => ({ v: VECTOR_GRAPH_PART_PAYLOAD_VERSION, fieldName: state.fieldName, graphs: [graph] }));
 }
 function readFile(state, planned, docIds, centroid) {
   const dimension = state.dimension;
@@ -8133,18 +7774,19 @@ function readFile(state, planned, docIds, centroid) {
     ordinals
   };
 }
-function planCheckpoint(state, listedKeys) {
+function planCheckpoint(state, listedKeys, rewritesGraph = false) {
   const signature = signatureOf(state);
   const calibration = signature.calibration;
   const trusted = registryMatches(state, listedKeys);
+  const capacity = fileCapacityOf(state);
   const liveCounts = [];
   const keptFiles = filesWorthKeeping(state, trusted ? state.savedFiles : [], calibration, liveCounts);
-  absorbSmallerPartialFiles(keptFiles, liveCounts, countOutside(state, liveCounts));
+  absorbSmallerPartialFiles(keptFiles, liveCounts, countOutside(state, liveCounts), capacity);
   const written = ordinalsOutsideOf(state, keptFiles);
   const writtenDocIds = written.map((ordinal) => state.store.docIdForOrdinal(ordinal) ?? "");
   const centroid = codedCentroid(state);
   const listedBefore = trusted && listedKeys !== null;
-  const unchanged = listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
+  const unchanged = !rewritesGraph && listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
   return {
     unchanged,
     keptFiles,
@@ -8154,12 +7796,12 @@ function planCheckpoint(state, listedKeys) {
       count: file.ordinals.length,
       dead: deadBitsOf(state, file)
     })),
-    newFiles: Math.ceil(written.length / VECTOR_FILE_MAX_VECTORS),
-    graph: unchanged ? null : graphOf(state, numberEveryVector(state, keptFiles, written)),
+    newFiles: Math.ceil(written.length / capacity),
+    graphParts: unchanged ? null : graphPartsOf(state, numberEveryVector(state, keptFiles, written)),
     signature,
     readNewFile(index) {
-      const start = index * VECTOR_FILE_MAX_VECTORS;
-      const end = start + VECTOR_FILE_MAX_VECTORS;
+      const start = index * capacity;
+      const end = start + capacity;
       return readFile(state, written.slice(start, end), writtenDocIds.slice(start, end), centroid);
     }
   };
@@ -8179,13 +7821,22 @@ function sameCentroid2(a, b) {
   return true;
 }
 function bufferEveryVectorOutsideTheGraph(state) {
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     if (state.hnsw === null || !state.hnsw.has(docId)) state.buffer.add(docId);
   }
 }
+function insertNodesOfLaterGraph(state, graph, later, ordinals) {
+  for (const part of later.parts) requireWholeNeighbourLists(part);
+  for (let number = 0; number < ordinals.length; number++) {
+    const ordinal = ordinals[number];
+    if (ordinal === NO_LIVE_VECTOR_AT_POSITION || topLayerInParts(later, number) < 0) continue;
+    const docId = state.store.docIdForOrdinal(ordinal);
+    if (docId !== void 0 && !graph.has(docId)) graph.insertOrdinal(ordinal);
+  }
+}
 function restoreGraph(state, payload, ordinalOfNumber) {
-  const first = payload?.graphs[0];
+  const first = payload?.graphs[0]?.parts[0];
   if (payload === null || first === void 0) {
     bufferEveryVectorOutsideTheGraph(state);
     return;
@@ -8196,17 +7847,9 @@ function restoreGraph(state, payload, ordinalOfNumber) {
     { m: first.m, efConstruction: first.efConstruction, metric: first.metric },
     state.osq ?? void 0
   );
-  graph.deserializeNumbered(first, ordinalOfNumber);
+  graph.deserializeNumbered(payload.graphs[0], ordinalOfNumber);
   adoptGraph(state, graph);
-  for (const later of payload.graphs.slice(1)) {
-    requireWholeNeighbourLists(later);
-    for (let number = 0; number < later.levels.length && number < ordinalOfNumber.length; number++) {
-      const ordinal = ordinalOfNumber[number];
-      if (later.levels[number] === 0 || ordinal === NO_LIVE_VECTOR_AT_POSITION) continue;
-      const docId = state.store.docIdForOrdinal(ordinal);
-      if (docId !== void 0 && !graph.has(docId)) graph.insertOrdinal(ordinal);
-    }
-  }
+  for (const later of payload.graphs.slice(1)) insertNodesOfLaterGraph(state, graph, later, ordinalOfNumber);
   bufferEveryVectorOutsideTheGraph(state);
   if (state.buffer.size <= graph.size) return;
   adoptGraph(state, null);
@@ -8887,12 +8530,11 @@ function createVectorIndex(fieldName, dimension, config, workerCopies = VECTOR_W
     },
     maintenanceStatus: () => maintenanceStatus(state),
     estimateMemoryBytes: () => estimateMemoryBytes(state),
-    serialize: () => serialize(state),
     deserialize: (parts) => {
       invalidateWorkerCopies(state);
       deserialize(state, parts);
     },
-    planCheckpoint: (listedKeys) => planCheckpoint(state, listedKeys),
+    planCheckpoint: (listedKeys, rewritesGraph) => planCheckpoint(state, listedKeys, rewritesGraph),
     recordCheckpoint: (plan, written) => recordCheckpoint(state, plan, written),
     restoreCheckpoint: (shape) => {
       invalidateWorkerCopies(state);
@@ -9010,11 +8652,46 @@ function createFrozenDocTable(idTable, lengthColumns, documents, tombstones) {
     }
   };
 }
+function removeFieldAtPath(document, fieldPath) {
+  const segments = fieldPath.split(".");
+  let current = document;
+  for (let i = 0; i < segments.length - 1; i += 1) {
+    const next = current[segments[i]];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) return;
+    current = next;
+  }
+  delete current[segments[segments.length - 1]];
+}
+function decodeStoredDocument(bytes, discardedFields) {
+  let decoded;
+  try {
+    decoded = decode(bytes);
+  } catch (error) {
+    throw new NarsilError(
+      ErrorCodes.PERSISTENCE_LOAD_FAILED,
+      `A stored document is not MessagePack: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded) || decoded instanceof Uint8Array) {
+    throw new NarsilError(ErrorCodes.PERSISTENCE_LOAD_FAILED, "A stored document decodes to something other than a map");
+  }
+  const document = decoded;
+  if (discardedFields !== void 0) {
+    for (const fieldPath of discardedFields) removeFieldAtPath(document, fieldPath);
+  }
+  return document;
+}
+function decodeEveryStoredDocument(data) {
+  const count = data.offsets.length - 1;
+  for (let ordinal = 0; ordinal < count; ordinal++) {
+    decodeStoredDocument(data.blob.subarray(data.offsets[ordinal], data.offsets[ordinal + 1]), data.discardedFields);
+  }
+}
 function encodeDocumentTableData(documents) {
   const encoded = new Array(documents.length);
   let blobLength = 0;
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
-    const bytes = encode(documents[ordinal]);
+    const bytes = encodeDocument(documents[ordinal]);
     encoded[ordinal] = bytes;
     blobLength += bytes.length;
   }
@@ -9042,7 +8719,7 @@ function wrapEncodedDocumentTable(data) {
     docAt(ordinal) {
       let document = decoded[ordinal];
       if (document === void 0) {
-        document = decode(blob.slice(offsets[ordinal], offsets[ordinal + 1]));
+        document = decodeStoredDocument(blob.slice(offsets[ordinal], offsets[ordinal + 1]), data.discardedFields);
         decoded[ordinal] = document;
         decodedBytes += documentValueBytes(document);
       }
@@ -9346,7 +9023,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++) {
@@ -9662,6 +9354,9 @@ function wrapFrozenTokenTable(data) {
       }
       return token;
     },
+    byteLengthAt(sortedIndex) {
+      return offsets[sortedIndex + 1] - offsets[sortedIndex];
+    },
     payloadSlot(sortedIndex) {
       return payloadSlots[sortedIndex];
     },
@@ -9750,6 +9445,34 @@ function sharedSurfaceTable(payload) {
   if (table.counts.length === 0) return null;
   return { blob: sharedUint8(table.blob), offsets: sharedUint32(table.offsets), counts: sharedUint32(table.counts) };
 }
+function segmentArraysOf(payload, documentData) {
+  const tokenTable = encodeFrozenTokenTableData(payload.tokens, payload.docFrequencies);
+  const idTable = encodeExternalIdTableData(payload.docIds);
+  const surfaceTable = payload.surfaceForms === null ? null : encodeSurfaceTable(payload.surfaceForms);
+  return {
+    documentCount: payload.documentCount,
+    fieldNames: payload.fieldNames,
+    fieldLengthNames: payload.fieldLengthNames,
+    fieldLengthColumns: payload.fieldLengthColumns,
+    totalFieldLengths: payload.totalFieldLengths,
+    tokenTable,
+    idTable,
+    documentTable: documentData,
+    postingOffsets: payload.postingOffsets,
+    postingDocIds: payload.postingDocIds,
+    postingFrequencies: payload.postingFrequencies,
+    postingFieldIndices: payload.postingFieldIndices,
+    positionOffsets: payload.positionOffsets,
+    positionValues: payload.positionValues,
+    numeric: payload.numeric,
+    sizes: payload.sizes,
+    boolean: payload.boolean,
+    enums: payload.enums,
+    geo: payload.geo,
+    pattern: payload.pattern,
+    surfaceTable: surfaceTable === null || surfaceTable.counts.length === 0 ? null : surfaceTable
+  };
+}
 function freezeSegmentShared(payload, documents, segmentId) {
   if (typeof SharedArrayBuffer !== "function") return null;
   return freezeEncodedSegmentShared(payload, encodeDocumentTableData(documents), segmentId);
@@ -9778,12 +9501,13 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
     },
     documentTable: {
       blob: sharedUint8(documentData.blob),
-      offsets: sharedUint32(documentData.offsets)
+      offsets: sharedUint32(documentData.offsets),
+      ...documentData.discardedFields === void 0 ? {} : { discardedFields: documentData.discardedFields }
     },
     postingOffsets: sharedUint32(payload.postingOffsets),
     postingDocIds: sharedUint32(payload.postingDocIds),
     postingFrequencies: sharedUint16(payload.postingFrequencies),
-    postingFieldIndices: sharedUint8(payload.postingFieldIndices),
+    postingFieldIndices: sharedUint16(payload.postingFieldIndices),
     positionOffsets: payload.positionOffsets === null ? null : sharedUint32(payload.positionOffsets),
     positionValues: payload.positionValues === null ? null : sharedUint32(payload.positionValues),
     numeric: payload.numeric.map((entry) => ({
@@ -9791,6 +9515,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 +9537,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 +9590,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 +9617,8 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     booleanIndexes,
     enumIndexes,
     geoIndexes: buildGeoReaders(source.geo),
+    patternIndexes,
+    sizeIndexes,
     fieldNameTable,
     trackPositions: source.positionOffsets !== null,
     flatSchemaCache: null,
@@ -9946,6 +9690,133 @@ function createSharedFrozenSegment(snapshot) {
     snapshot
   );
 }
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var keyDecoder = new TextDecoder("utf-8", { fatal: true });
+function headerAt(view, offset) {
+  if (offset >= view.byteLength) return null;
+  const tag = view.getUint8(offset);
+  if (tag <= 127 || tag >= 224) return { headerBytes: 1, bodyBytes: 0, children: 0 };
+  if (tag <= 143) return { headerBytes: 1, bodyBytes: 0, children: (tag & 15) * 2 };
+  if (tag <= 159) return { headerBytes: 1, bodyBytes: 0, children: tag & 15 };
+  if (tag <= 191) return { headerBytes: 1, bodyBytes: tag & 31, children: 0 };
+  const lengthBytes = LENGTH_BYTES_BY_TAG.get(tag);
+  if (lengthBytes !== void 0) {
+    if (offset + 1 + lengthBytes > view.byteLength) return null;
+    const length = lengthBytes === 1 ? view.getUint8(offset + 1) : lengthBytes === 2 ? view.getUint16(offset + 1, false) : view.getUint32(offset + 1, false);
+    const headerBytes = 1 + lengthBytes;
+    if (ARRAY_TAGS.has(tag)) return { headerBytes, bodyBytes: 0, children: length };
+    if (MAP_TAGS.has(tag)) return { headerBytes, bodyBytes: 0, children: length * 2 };
+    return { headerBytes, bodyBytes: length + (EXT_TAGS.has(tag) ? 1 : 0), children: 0 };
+  }
+  const fixedBytes = FIXED_BODY_BYTES_BY_TAG.get(tag);
+  return fixedBytes === void 0 ? null : { headerBytes: 1, bodyBytes: fixedBytes, children: 0 };
+}
+var LENGTH_BYTES_BY_TAG = /* @__PURE__ */ new Map([
+  [196, 1],
+  [197, 2],
+  [198, 4],
+  [199, 1],
+  [200, 2],
+  [201, 4],
+  [217, 1],
+  [218, 2],
+  [219, 4],
+  [220, 2],
+  [221, 4],
+  [222, 2],
+  [223, 4]
+]);
+var ARRAY_TAGS = /* @__PURE__ */ new Set([220, 221]);
+var MAP_TAGS = /* @__PURE__ */ new Set([222, 223]);
+var EXT_TAGS = /* @__PURE__ */ new Set([199, 200, 201]);
+var FIXED_BODY_BYTES_BY_TAG = /* @__PURE__ */ new Map([
+  [192, 0],
+  [194, 0],
+  [195, 0],
+  [202, 4],
+  [203, 8],
+  [204, 1],
+  [205, 2],
+  [206, 4],
+  [207, 8],
+  [208, 1],
+  [209, 2],
+  [210, 4],
+  [211, 8],
+  [212, 2],
+  [213, 3],
+  [214, 5],
+  [215, 9],
+  [216, 17]
+]);
+function endOfValue(view, start) {
+  let offset = start;
+  let pending = 1;
+  while (pending > 0) {
+    const header = headerAt(view, offset);
+    if (header === null) return null;
+    offset += header.headerBytes + header.bodyBytes;
+    if (offset > view.byteLength) return null;
+    pending += header.children - 1;
+  }
+  return offset;
+}
+function stringKeyAt(bytes, view, offset) {
+  const header = headerAt(view, offset);
+  if (header === null || header.children !== 0) return null;
+  const tag = view.getUint8(offset);
+  const isString = tag >= 160 && tag <= 191 || tag === 217 || tag === 218 || tag === 219;
+  const end = offset + header.headerBytes + header.bodyBytes;
+  if (!isString || end > bytes.length) return null;
+  try {
+    return { key: keyDecoder.decode(bytes.subarray(offset + header.headerBytes, end)), end };
+  } catch {
+    return null;
+  }
+}
+function topLevelMapKeys(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const top = headerAt(view, 0);
+  if (top === null || top.bodyBytes !== 0) return null;
+  const tag = view.getUint8(0);
+  if (!(tag >= 128 && tag <= 143 || MAP_TAGS.has(tag))) return null;
+  const keys = /* @__PURE__ */ new Set();
+  let offset = top.headerBytes;
+  for (let pair = 0; pair < top.children / 2; pair += 1) {
+    const key = stringKeyAt(bytes, view, offset);
+    if (key === null) return null;
+    const valueEnd = endOfValue(view, key.end);
+    if (valueEnd === null) return null;
+    keys.add(key.key);
+    offset = valueEnd;
+  }
+  return keys;
+}
+function decodeMapWithoutFields(bytes, skippedFields) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const top = headerAt(view, 0);
+  if (top === null || top.children === 0 || top.bodyBytes !== 0) return null;
+  const tag = view.getUint8(0);
+  const isMap = tag >= 128 && tag <= 143 || MAP_TAGS.has(tag);
+  if (!isMap) return null;
+  const document = {};
+  let offset = top.headerBytes;
+  for (let pair = 0; pair < top.children / 2; pair += 1) {
+    const key = stringKeyAt(bytes, view, offset);
+    if (key === null || FORBIDDEN_KEYS.has(key.key)) return null;
+    const valueEnd = endOfValue(view, key.end);
+    if (valueEnd === null) return null;
+    if (!skippedFields.has(key.key)) {
+      try {
+        document[key.key] = decode(bytes.subarray(key.end, valueEnd));
+      } catch {
+        return null;
+      }
+    }
+    offset = valueEnd;
+  }
+  return offset === bytes.length ? document : null;
+}
 
 // src/core/partition/frozen/merge-fields.ts
 function indexByFieldPath(entries) {
@@ -10002,12 +9873,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 +9947,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)
   };
 }
 
@@ -10192,7 +10079,7 @@ function mergePostings2(inputs) {
   const postingOffsets = new Uint32Array(tokenCount + 1);
   const postingDocIds = new Uint32Array(totalPostings);
   const postingFrequencies = new Uint16Array(totalPostings);
-  const postingFieldIndices = new Uint8Array(totalPostings);
+  const postingFieldIndices = new Uint16Array(totalPostings);
   const positionOffsets = hasPositions ? new Uint32Array(totalPostings + 1) : null;
   const positionValues = hasPositions ? new Uint32Array(totalPositions) : null;
   let postingCursor = 0;
@@ -10266,11 +10153,15 @@ function mergePostings2(inputs) {
 }
 
 // src/core/partition/frozen/merge.ts
-function remapOf(segment, docIds) {
+function selectionKeeps(selection, ordinal) {
+  return selection.keep === void 0 ? !selection.segment.isTombstoned(ordinal) : selection.keep(ordinal);
+}
+function remapOf(selection, docIds) {
+  const { segment } = selection;
   const count = segment.arrays.documentCount;
   const remap = new Int32Array(count).fill(-1);
   for (let ordinal = 0; ordinal < count; ordinal++) {
-    if (segment.isTombstoned(ordinal)) continue;
+    if (!selectionKeeps(selection, ordinal)) continue;
     remap[ordinal] = docIds.length;
     docIds.push(segment.arrays.idTable.idAt(ordinal));
   }
@@ -10283,7 +10174,7 @@ function fieldNameIndex(fieldNames, name) {
   return fieldNames.length - 1;
 }
 function fieldIndexRemapOf(segment, fieldNames) {
-  const remap = new Uint8Array(segment.arrays.fieldNames.length);
+  const remap = new Uint16Array(segment.arrays.fieldNames.length);
   for (let i = 0; i < segment.arrays.fieldNames.length; i++) {
     remap[i] = fieldNameIndex(fieldNames, segment.arrays.fieldNames[i]);
   }
@@ -10329,20 +10220,34 @@ function mergeSurfaceForms2(inputs) {
   }
   return registry.size() === 0 ? null : registry.serialize();
 }
+function holdsADiscardedField(bytes, discardedFields) {
+  const keys = topLevelMapKeys(bytes);
+  if (keys === null) return true;
+  for (const fieldPath of discardedFields) {
+    const dot = fieldPath.indexOf(".");
+    if (keys.has(dot < 0 ? fieldPath : fieldPath.slice(0, dot))) return true;
+  }
+  return false;
+}
 function encodedDocumentsOf(input) {
   const table = input.segment.arrays.documentTable;
-  if (table !== null) {
-    return (ordinal) => table.blob.subarray(table.offsets[ordinal], table.offsets[ordinal + 1]);
-  }
   const encoded = new Array(input.remap.length);
-  return (ordinal) => {
+  const encodeOrdinal = (ordinal) => {
     let bytes = encoded[ordinal];
     if (bytes === void 0) {
-      bytes = encode(input.segment.documentSource.docAt(ordinal));
+      bytes = encodeDocument(input.segment.documentSource.docAt(ordinal));
       encoded[ordinal] = bytes;
     }
     return bytes;
   };
+  if (table === null) return encodeOrdinal;
+  const discardedFields = table.discardedFields;
+  return (ordinal) => {
+    if (encoded[ordinal] !== void 0) return encodeOrdinal(ordinal);
+    const stored = table.blob.subarray(table.offsets[ordinal], table.offsets[ordinal + 1]);
+    if (discardedFields === void 0 || !holdsADiscardedField(stored, discardedFields)) return stored;
+    return encodeOrdinal(ordinal);
+  };
 }
 function mergeDocuments2(inputs, documentCount) {
   const readers = inputs.map(encodedDocumentsOf);
@@ -10366,12 +10271,16 @@ function mergeDocuments2(inputs, documentCount) {
 }
 function mergeFrozenSegments(segments) {
   if (typeof SharedArrayBuffer !== "function") return null;
+  const merged = mergeSegmentContents(segments.map((segment) => ({ segment })));
+  return freezeEncodedSegmentShared(merged.payload, merged.documents);
+}
+function mergeSegmentContents(selections) {
   const docIds = [];
   const fieldNames = [];
-  const inputs = segments.map((segment) => ({
-    segment,
-    remap: remapOf(segment, docIds),
-    fieldIndexRemap: fieldIndexRemapOf(segment, fieldNames)
+  const inputs = selections.map((selection) => ({
+    segment: selection.segment,
+    remap: remapOf(selection, docIds),
+    fieldIndexRemap: fieldIndexRemapOf(selection.segment, fieldNames)
   }));
   const documentCount = docIds.length;
   const postings = mergePostings2(inputs);
@@ -10394,87 +10303,10 @@ function mergeFrozenSegments(segments) {
     surfaceForms: mergeSurfaceForms2(inputs),
     ...mergeFieldIndexes2(inputs)
   };
-  return freezeEncodedSegmentShared(payload, mergeDocuments2(inputs, documentCount));
+  return { payload, documents: 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 +10315,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++;
@@ -10585,7 +10417,7 @@ var TextPostings = class {
     const writeCursor = postingOffsets.slice(0, tokenCount);
     const postingDocIds = new Uint32Array(postings);
     const postingFrequencies = new Uint16Array(postings);
-    const postingFieldIndices = new Uint8Array(postings);
+    const postingFieldIndices = new Uint16Array(postings);
     const logRowOfPosting = new Uint32Array(postings);
     for (let row = 0; row < postings; row++) {
       const target = writeCursor[this.logToken.values[row]]++;
@@ -10626,11 +10458,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 +10567,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 +10578,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 +11033,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 +11044,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 +11064,7 @@ function createDirectExecutor(options) {
           entry.language,
           entry.config.schema,
           { scoringMode: entry.config.defaultScoring ?? "local" },
-          entry.searchOptions
+          searchOptions
         );
         return { count: result.totalMatched };
       }
@@ -11266,4 +11150,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 { CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_FILE_BYTES, NATIVE_CRC32_MIN_BYTES, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VALID_HNSW_METRICS, VECTOR_FILE_MAX_VECTORS, VECTOR_FILE_PAYLOAD_VERSION, assembleGraphParts, buildSegmentPayload, bytesToVectors, countDead, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeEveryStoredDocument, decodeMapWithoutFields, decodeStoredDocument, decodeVectorFilePayload, decodeVectorGraphPartPayload, decodeVectorGraphPayload, decodeVectorIndexParts, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, graphPartsOfEarlierPayload, hasStopWords, hasTokenizer, isCompositePartition, isDead, mergeFrozenSegments, mergeSegmentContents, missingWorkerEntry, nodeThreadId, partitionStateOf, readHeapStatistics, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };