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

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

@@ -1,16 +1,19 @@
-import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-QR4OKRVY.mjs';
-import { getLanguage, detectRuntime } from './chunk-KZTI25D3.mjs';
-import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, requireValidFieldTypes, extractVectorFieldsFromSchema, VECTOR_PATTERN, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-M6XF5HDE.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-LCCL6EEH.mjs';
-import { noteFallback } from './chunk-P2ZZN32C.mjs';
-import { VALID_HNSW_METRICS } from './chunk-IFBKLBGB.mjs';
-import { GrowableUint32, patternSearchModule } from './chunk-3HQPUCCT.mjs';
+import { joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, projectionKeepsField, setNestedValue, fnv1a, everyValueFacetConfig, mergeFacets, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-VKX2BPXD.mjs';
+import { getLanguage, detectRuntime } from './chunk-4MQ5F4IL.mjs';
+import { MAX_DOC_ID_LENGTH } from './chunk-3DDUNI6N.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-PO53FV4Q.mjs';
+import { noteFallback } from './chunk-2E35UM3G.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, compareComparableValues, defaultSortMode, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { encodePartialSpellings, countSpelling, expandTermPrefix, suggestDisplayTerms, spellingCountsOf, codePointOrder, encodeStringBlob, partialWordSearchModule, partitionDocumentFrequency } from './chunk-T5ZWEWVD.mjs';
+import { tokenizeOptions, getNestedValue, visitTokens, textFieldsChanged, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId } from './chunk-I23G3IZC.mjs';
+import { schemaFieldsOf, partialFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-Z3DQPOJQ.mjs';
+import { MAX_M, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-KEHK2O6P.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+)$/;
@@ -118,518 +121,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 patternIndexesToWire(pattern) {
-  if (pattern === void 0) return {};
-  const wire = /* @__PURE__ */ Object.create(null);
-  for (const [field, index] of Object.entries(pattern)) wire[field] = { doc_ids: index.docIds, runs: index.runs };
-  return { pattern: wire };
-}
-function isWireRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function corruptPatternEntry(field) {
-  return new NarsilError(
-    ErrorCodes.PERSISTENCE_LOAD_FAILED,
-    `The pattern entry of field "${field}" in this partition must hold a list of document IDs and a map of runs`,
-    { field }
-  );
-}
-function patternIndexesFromWire(raw) {
-  if (raw === void 0 || raw === null) return {};
-  if (!isWireRecord(raw)) {
-    throw new NarsilError(
-      ErrorCodes.PERSISTENCE_LOAD_FAILED,
-      "The pattern entry of this partition must be a map of fields"
-    );
-  }
-  const pattern = /* @__PURE__ */ Object.create(null);
-  for (const [field, index] of Object.entries(raw)) {
-    if (!isWireRecord(index) || !isWireRecord(index.runs) || !Array.isArray(index.doc_ids)) {
-      throw corruptPatternEntry(field);
-    }
-    const docIds = [];
-    for (const docId of index.doc_ids) {
-      if (typeof docId !== "string") throw corruptPatternEntry(field);
-      docIds.push(docId);
-    }
-    pattern[field] = { docIds, runs: index.runs };
-  }
-  return { pattern };
-}
-function validateHnswMetric(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
-    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,
-      ...patternIndexesFromWire(raw.field_indexes?.pattern)
-    },
-    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,
-      ...patternIndexesFromWire(raw.field_indexes?.pattern)
-    },
-    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) {
@@ -889,7 +380,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(),
@@ -903,7 +394,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;
 }
@@ -924,8 +415,6 @@ function compactList(list) {
         }
       }
       writeIdx++;
-    } else {
-      list.totalTermFrequency -= list.termFrequencies[i];
     }
   }
   list.docIds.length = writeIdx;
@@ -950,8 +439,6 @@ function compactDocEntries(list, internalId) {
         }
       }
       writeIdx++;
-    } else {
-      list.totalTermFrequency -= list.termFrequencies[i];
     }
   }
   list.docIds.length = writeIdx;
@@ -1037,12 +524,13 @@ function createInvertedIndex(fieldNameTable) {
       }
       list.length++;
     },
-    remove(token, internalId) {
+    remove(token, internalId, occurrences) {
       const list = index.get(token);
       if (!list || !list.docIdSet.has(internalId)) return;
       list.structureRevision++;
       list.docIdSet.delete(internalId);
       list.deletedDocs.add(internalId);
+      list.totalTermFrequency = Math.max(0, list.totalTermFrequency - occurrences);
       if (list.docIdSet.size === 0) {
         index.delete(token);
         untrackToken(token);
@@ -1075,6 +563,9 @@ function createInvertedIndex(fieldNameTable) {
     lookup(token) {
       return index.get(token);
     },
+    documentFrequency(token) {
+      return index.get(token)?.docIdSet.size ?? 0;
+    },
     fuzzyLookup(token, tolerance, prefixLength) {
       if (tolerance === 0) {
         const exact = index.get(token);
@@ -1148,7 +639,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;
@@ -2180,6 +1671,13 @@ function resolveInternalId(state, docId) {
   }
   return internalId;
 }
+function emptyIndexedText(fields) {
+  const holdsPartialField = fields.some((field) => field.partial);
+  return { fieldLengths: {}, tokensByField: {}, partialSpellings: holdsPartialField ? /* @__PURE__ */ new Map() : null };
+}
+function partialSpellingsFor(field, indexed) {
+  return field.partial ? indexed.partialSpellings : null;
+}
 function countSurface(counts, surface, token) {
   if (surface === void 0 || surface.length === 0) return;
   const existing = counts.get(surface);
@@ -2189,6 +1687,18 @@ function countSurface(counts, surface, token) {
     counts.set(surface, { token, count: 1 });
   }
 }
+function countOccurrence(counts, spellings, surface, token) {
+  countSurface(counts, surface, token);
+  if (spellings !== null) countSpelling(spellings, token, surface ?? token, 1);
+}
+function addFieldOccurrences(occurrencesByToken, fieldTokens) {
+  const fieldCounts = /* @__PURE__ */ new Map();
+  for (const token of fieldTokens) fieldCounts.set(token, (fieldCounts.get(token) ?? 0) + 1);
+  for (const [token, count] of fieldCounts) {
+    const stored = count > MAX_TERM_FREQUENCY ? MAX_TERM_FREQUENCY : count;
+    occurrencesByToken.set(token, (occurrencesByToken.get(token) ?? 0) + stored);
+  }
+}
 function applySurfaceCounts(state, counts, direction) {
   for (const [surface, entry] of counts) {
     if (direction === 1) {
@@ -2198,7 +1708,7 @@ function applySurfaceCounts(state, counts, direction) {
     }
   }
 }
-function indexStringField(state, internalId, fieldPath, text, language, options, fieldLengths, tokensByField) {
+function indexStringField(state, internalId, fieldPath, text, language, options, fieldLengths, tokensByField, spellings = null) {
   const fieldTokenList = [];
   const fieldNameIndex2 = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
   const opts = tokenizeOptions(options);
@@ -2214,7 +1724,7 @@ function indexStringField(state, internalId, fieldPath, text, language, options,
         tokenFreqs.set(t.token, { count: 1, positions: [t.position] });
       }
       fieldTokenList.push(t.token);
-      countSurface(surfaceCounts, t.surface, t.token);
+      countOccurrence(surfaceCounts, spellings, t.surface, t.token);
     }
     for (const [token, freq] of tokenFreqs) {
       state.invertedIdx.insert(token, internalId, freq.count, fieldNameIndex2, freq.positions);
@@ -2224,7 +1734,7 @@ function indexStringField(state, internalId, fieldPath, text, language, options,
     for (const t of tokenizeIterator(text, language, opts)) {
       tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
       fieldTokenList.push(t.token);
-      countSurface(surfaceCounts, t.surface, t.token);
+      countOccurrence(surfaceCounts, spellings, t.surface, t.token);
     }
     for (const [token, count] of tokenCounts) {
       state.invertedIdx.insert(token, internalId, count, fieldNameIndex2, null);
@@ -2234,7 +1744,7 @@ function indexStringField(state, internalId, fieldPath, text, language, options,
   fieldLengths[fieldPath] = fieldTokenList.length;
   tokensByField[fieldPath] = fieldTokenList;
 }
-function indexStringArrayField(state, internalId, fieldPath, arr, language, options, fieldLengths, tokensByField) {
+function indexStringArrayField(state, internalId, fieldPath, arr, language, options, fieldLengths, tokensByField, spellings = null) {
   const fieldTokenList = [];
   const fieldNameIndex2 = getOrCreateFieldNameIndex(state.fieldNameTable, fieldPath);
   const opts = tokenizeOptions(options);
@@ -2253,7 +1763,7 @@ function indexStringArrayField(state, internalId, fieldPath, arr, language, opti
           tokenFreqs.set(t.token, { count: 1, positions: [positionOffset + t.position] });
         }
         fieldTokenList.push(t.token);
-        countSurface(surfaceCounts, t.surface, t.token);
+        countOccurrence(surfaceCounts, spellings, t.surface, t.token);
         itemTokenCount++;
       }
       positionOffset += itemTokenCount;
@@ -2268,7 +1778,7 @@ function indexStringArrayField(state, internalId, fieldPath, arr, language, opti
       for (const t of tokenizeIterator(item, language, opts)) {
         tokenCounts.set(t.token, (tokenCounts.get(t.token) ?? 0) + 1);
         fieldTokenList.push(t.token);
-        countSurface(surfaceCounts, t.surface, t.token);
+        countOccurrence(surfaceCounts, spellings, t.surface, t.token);
       }
     }
     fieldLengths[fieldPath] = fieldTokenList.length;
@@ -2280,17 +1790,28 @@ function indexStringArrayField(state, internalId, fieldPath, arr, language, opti
   tokensByField[fieldPath] = fieldTokenList;
 }
 function indexDocument(state, docId, document, fields, language, options) {
-  const fieldLengths = {};
-  const tokensByField = {};
+  const indexed = emptyIndexedText(fields);
+  const { fieldLengths, tokensByField } = indexed;
   const internalId = resolveInternalId(state, docId);
-  for (const { path: fieldPath, base, pattern } of fields) {
+  for (const field of fields) {
+    const { path: fieldPath, base, pattern } = field;
     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);
+      indexStringField(
+        state,
+        internalId,
+        fieldPath,
+        value,
+        language,
+        options,
+        fieldLengths,
+        tokensByField,
+        partialSpellingsFor(field, indexed)
+      );
     } else if (base === "number") {
       getOrCreateNumericIndex(state, fieldPath).insert(internalId, value);
     } else if (base === "boolean") {
@@ -2309,7 +1830,8 @@ function indexDocument(state, docId, document, fields, language, options) {
         language,
         options,
         fieldLengths,
-        tokensByField
+        tokensByField,
+        partialSpellingsFor(field, indexed)
       );
     } else if (base === "number[]") {
       const numIdx = getOrCreateNumericIndex(state, fieldPath);
@@ -2324,15 +1846,17 @@ function indexDocument(state, docId, document, fields, language, options) {
       }
     }
   }
-  return { fieldLengths, tokensByField };
+  return indexed;
 }
 function removeFromIndexes(state, docId, storedDoc, schemaFields, language, options) {
-  const fieldLengths = {};
-  const tokensByField = {};
+  const removed = emptyIndexedText(schemaFields);
+  const { fieldLengths, tokensByField } = removed;
   const fields = storedDoc.fields;
   const internalId = resolveInternalId(state, docId);
   const opts = tokenizeOptions(options);
-  for (const { path: fieldPath, base, pattern } of schemaFields) {
+  const occurrencesByToken = /* @__PURE__ */ new Map();
+  for (const field of schemaFields) {
+    const { path: fieldPath, base, pattern } = field;
     const value = getNestedValue(fields, fieldPath);
     if (value === void 0 || value === null) continue;
     forgetValueSize(state.sizeIndexes, internalId, fieldPath, base, value);
@@ -2340,16 +1864,15 @@ function removeFromIndexes(state, docId, storedDoc, schemaFields, language, opti
     if (base === "string") {
       const result = tokenize(value, language, opts);
       fieldLengths[fieldPath] = result.tokens.length;
-      const uniqueTokens = /* @__PURE__ */ new Set();
       const fieldTokenList = [];
       const surfaceCounts = /* @__PURE__ */ new Map();
+      const spellings = partialSpellingsFor(field, removed);
       for (let i = 0; i < result.tokens.length; i++) {
         const t = result.tokens[i];
-        uniqueTokens.add(t.token);
         fieldTokenList.push(t.token);
-        countSurface(surfaceCounts, result.surfaces?.[i], t.token);
+        countOccurrence(surfaceCounts, spellings, result.surfaces?.[i], t.token);
       }
-      for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
+      addFieldOccurrences(occurrencesByToken, fieldTokenList);
       applySurfaceCounts(state, surfaceCounts, -1);
       tokensByField[fieldPath] = fieldTokenList;
     } else if (base === "number") {
@@ -2362,20 +1885,19 @@ function removeFromIndexes(state, docId, storedDoc, schemaFields, language, opti
       state.geoIndexes.get(fieldPath)?.remove(internalId);
     } else if (base === "string[]") {
       const arr = value;
-      const uniqueTokens = /* @__PURE__ */ new Set();
       const fieldTokenList = [];
       const surfaceCounts = /* @__PURE__ */ new Map();
+      const spellings = partialSpellingsFor(field, removed);
       for (const item of arr) {
         const result = tokenize(item, language, opts);
         for (let i = 0; i < result.tokens.length; i++) {
           const t = result.tokens[i];
-          uniqueTokens.add(t.token);
           fieldTokenList.push(t.token);
-          countSurface(surfaceCounts, result.surfaces?.[i], t.token);
+          countOccurrence(surfaceCounts, spellings, result.surfaces?.[i], t.token);
         }
       }
       fieldLengths[fieldPath] = fieldTokenList.length;
-      for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
+      addFieldOccurrences(occurrencesByToken, fieldTokenList);
       applySurfaceCounts(state, surfaceCounts, -1);
       tokensByField[fieldPath] = fieldTokenList;
     } else if (base === "number[]") {
@@ -2395,7 +1917,8 @@ function removeFromIndexes(state, docId, storedDoc, schemaFields, language, opti
       }
     }
   }
-  return { fieldLengths, tokensByField };
+  for (const [token, occurrences] of occurrencesByToken) state.invertedIdx.remove(token, internalId, occurrences);
+  return removed;
 }
 
 // src/core/partition/field-updates.ts
@@ -3530,6 +3053,67 @@ function partitionFilterMatches(state, filters, schema, meter) {
   };
 }
 
+// src/core/scorer.ts
+var DEFAULT_K1 = 1.2;
+var DEFAULT_B = 0.75;
+function computeIDF(docFrequency, totalDocs) {
+  if (totalDocs === 0) return 0;
+  return Math.log((totalDocs - docFrequency + 0.5) / (docFrequency + 0.5) + 1);
+}
+function bm25PruningSound(params) {
+  const k1 = params?.k1 ?? DEFAULT_K1;
+  const b = params?.b ?? DEFAULT_B;
+  return Number.isFinite(k1) && k1 >= 0 && b >= 0 && b <= 1;
+}
+function resolveBM25Params(params) {
+  return { k1: params?.k1 ?? DEFAULT_K1, b: params?.b ?? DEFAULT_B };
+}
+function computeBM25WithIDF(termFrequency, idf, fieldLength, avgFieldLength, k1, b) {
+  if (avgFieldLength === 0) return 0;
+  const numerator = termFrequency * (k1 + 1);
+  const denominator = termFrequency + k1 * (1 - b + b * fieldLength / avgFieldLength);
+  if (denominator === 0) return 0;
+  return idf * (numerator / denominator);
+}
+function computeBM25(termFrequency, docFrequency, totalDocs, fieldLength, avgFieldLength, params) {
+  if (totalDocs === 0) return 0;
+  const k1 = params?.k1 ?? DEFAULT_K1;
+  const b = params?.b ?? DEFAULT_B;
+  return computeBM25WithIDF(termFrequency, computeIDF(docFrequency, totalDocs), fieldLength, avgFieldLength, k1, b);
+}
+
+// src/core/partition/field-scoring.ts
+function loadFieldScoring(state, fields, boost, averageFieldLengths) {
+  const fieldNames = state.fieldNameTable.names;
+  const scoring = {
+    searchable: new Uint8Array(fieldNames.length),
+    boosts: new Float64Array(fieldNames.length),
+    averageLengths: new Float64Array(fieldNames.length),
+    lengthColumns: new Array(fieldNames.length).fill(null)
+  };
+  for (let fieldIndex = 0; fieldIndex < fieldNames.length; fieldIndex++) {
+    const fieldName = fieldNames[fieldIndex];
+    scoring.searchable[fieldIndex] = fields === void 0 || fields.includes(fieldName) ? 1 : 0;
+    scoring.boosts[fieldIndex] = boost?.[fieldName] ?? 1;
+    scoring.averageLengths[fieldIndex] = averageFieldLengths[fieldName] ?? 1;
+    scoring.lengthColumns[fieldIndex] = state.docStore.fieldLengthColumn(fieldName);
+  }
+  return scoring;
+}
+function fieldLengthOf(columns, fieldIndex, internalId, averageLength) {
+  const column = fieldIndex < columns.length ? columns[fieldIndex] : null;
+  if (column === null || internalId >= column.length) return averageLength;
+  const stored = column[internalId];
+  return stored > 0 ? stored : averageLength;
+}
+function bestSearchable(searchable, values) {
+  let best = 0;
+  for (let index = 0; index < searchable.length; index++) {
+    if (searchable[index] === 1 && values[index] > best) best = values[index];
+  }
+  return best;
+}
+
 // src/core/partition/posting-columns.ts
 function postingColumns(list) {
   const deletedDocs = list.deletedDocs;
@@ -3543,39 +3127,174 @@ function postingColumns(list) {
   };
 }
 
-// src/core/partition/matches.ts
-function markPostingList(matched, list, fieldNames, fields, filterBitset) {
-  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
-  for (let pi = 0; pi < count; pi++) {
-    const internalId = docIds[pi];
-    if (hasDeleted && deletedDocs.has(internalId)) continue;
-    if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-    if (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) continue;
-    bitsetSet(matched, internalId);
+// src/core/partition/scoring.ts
+var EMPTY_COMPONENTS = Object.freeze({});
+function recordComponents(components, internalId, fieldName, token, termFrequency, fieldLength, idf) {
+  const existing = components.get(internalId);
+  if (existing) {
+    existing.termFrequencies[`${fieldName}:${token}`] = termFrequency;
+    existing.fieldLengths[fieldName] = fieldLength;
+    existing.idf[token] = idf;
+    return;
   }
+  components.set(internalId, {
+    termFrequencies: { [`${fieldName}:${token}`]: termFrequency },
+    fieldLengths: { [fieldName]: fieldLength },
+    idf: { [token]: idf }
+  });
 }
-function searchFulltextMatches(state, params) {
-  const { queryTokens, prefixExpansion, fields, tolerance = 0, prefixLength = 2, exact = false, filterBitset } = params;
-  const fieldNames = state.fieldNameTable.names;
-  const matched = createBitSet(state.docStore.internalIdCapacity());
-  for (const qt of queryTokens) {
-    if (prefixExpansion && qt.token === prefixExpansion.token) {
-      const seen = /* @__PURE__ */ new Set();
-      for (const term of [qt.token, ...prefixExpansion.terms]) {
-        if (seen.has(term)) continue;
-        seen.add(term);
-        const postingList = state.invertedIdx.lookup(term);
-        if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
-      }
-      continue;
-    }
-    if (exact || tolerance === 0) {
-      const postingList = state.invertedIdx.lookup(qt.token);
-      if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
-      continue;
-    }
-    for (const match of state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength)) {
-      markPostingList(matched, match.postingList, fieldNames, fields, filterBitset);
+function mergeGroupComponents(components, internalId, contribution) {
+  const existing = components.get(internalId);
+  if (existing) {
+    Object.assign(existing.termFrequencies, contribution.termFrequencies);
+    Object.assign(existing.fieldLengths, contribution.fieldLengths);
+    existing.idf[contribution.token] = contribution.idf;
+    return;
+  }
+  components.set(internalId, {
+    termFrequencies: contribution.termFrequencies,
+    fieldLengths: contribution.fieldLengths,
+    idf: { [contribution.token]: contribution.idf }
+  });
+}
+
+// src/core/partition/group-scoring.ts
+function partialFieldMarks(fieldNames, partialFields) {
+  const marks = new Uint8Array(fieldNames.length);
+  if (partialFields === void 0 || partialFields.length === 0) return marks;
+  for (let fieldIndex = 0; fieldIndex < fieldNames.length; fieldIndex++) {
+    if (partialFields.includes(fieldNames[fieldIndex])) marks[fieldIndex] = 1;
+  }
+  return marks;
+}
+function termGroupOf(groups, token) {
+  if (groups === void 0) return void 0;
+  for (const group of groups) {
+    if (group.token === token) return group;
+  }
+  return void 0;
+}
+function typoMatchesFor(index, token, group, exact, tolerance, prefixLength) {
+  if (group !== void 0) {
+    if (!group.typoMatches || exact || tolerance === 0) return [];
+    return index.fuzzyLookup(token, tolerance, prefixLength).filter((match) => match.token !== token);
+  }
+  if (!exact) return index.fuzzyLookup(token, tolerance, prefixLength);
+  const postingList = index.lookup(token);
+  return postingList ? [{ token, postingList }] : [];
+}
+function resolveGroupMatches(context, group) {
+  let groupDocumentFrequency = 0;
+  const found = [];
+  for (const member of group.members) {
+    const documents = context.globalFrequency(member.token) ?? context.index.documentFrequency(member.token);
+    if (documents > groupDocumentFrequency) groupDocumentFrequency = documents;
+    const postingList = context.index.lookup(member.token);
+    if (postingList === void 0) continue;
+    found.push({ token: member.token, factor: member.factor, partialFactor: member.partialFactor, postingList });
+  }
+  if (found.length === 0) return [];
+  const idf = computeIDF(groupDocumentFrequency, context.totalDocs);
+  return found.map((entry) => ({ ...entry, idf }));
+}
+function groupPostingCount(matches) {
+  let total = 0;
+  for (const match of matches) total += match.postingList.length;
+  return total;
+}
+function computeGroupContributions(context, matches, collect) {
+  const { fields, fieldNames, filterBitset, partialMarks, k1, b } = context;
+  const scoresAreZero = context.totalDocs === 0;
+  const best = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const perTerm = /* @__PURE__ */ new Map();
+    const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+      match.postingList
+    );
+    for (let pi = 0; pi < count; pi++) {
+      const internalId = docIds[pi];
+      if (hasDeleted && deletedDocs.has(internalId)) continue;
+      if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
+      const fieldIndex = fieldNameIndices[pi];
+      if (fields.searchable[fieldIndex] === 0) continue;
+      const factor = partialMarks[fieldIndex] === 1 ? match.partialFactor : match.factor;
+      if (factor === 0) continue;
+      const fieldName = fieldNames[fieldIndex];
+      const termFrequency = termFrequencies[pi];
+      const fieldBoost = fields.boosts[fieldIndex];
+      const avgLen = fields.averageLengths[fieldIndex];
+      const actualFieldLength = fieldLengthOf(fields.lengthColumns, fieldIndex, internalId, avgLen);
+      const termScore = (scoresAreZero ? 0 : computeBM25WithIDF(termFrequency, match.idf, actualFieldLength, avgLen, k1, b)) * fieldBoost * factor;
+      const existing = perTerm.get(internalId);
+      if (existing) {
+        existing.score += termScore;
+        if (collect) {
+          existing.termFrequencies[`${fieldName}:${match.token}`] = termFrequency;
+          existing.fieldLengths[fieldName] = actualFieldLength;
+        }
+      } else if (collect) {
+        perTerm.set(internalId, {
+          score: termScore,
+          token: match.token,
+          idf: match.idf,
+          termFrequencies: { [`${fieldName}:${match.token}`]: termFrequency },
+          fieldLengths: { [fieldName]: actualFieldLength }
+        });
+      } else {
+        perTerm.set(internalId, {
+          score: termScore,
+          token: match.token,
+          idf: match.idf,
+          termFrequencies: EMPTY_COMPONENTS,
+          fieldLengths: EMPTY_COMPONENTS
+        });
+      }
+    }
+    for (const [internalId, contribution] of perTerm) {
+      const current = best.get(internalId);
+      if (!current || contribution.score > current.score) {
+        best.set(internalId, contribution);
+      }
+    }
+  }
+  return best;
+}
+
+// src/core/partition/matches.ts
+function markPostingList(matched, list, markedFields, filterBitset) {
+  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
+  for (let pi = 0; pi < count; pi++) {
+    const internalId = docIds[pi];
+    if (hasDeleted && deletedDocs.has(internalId)) continue;
+    if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
+    if (markedFields[fieldNameIndices[pi]] === 0) continue;
+    bitsetSet(matched, internalId);
+  }
+}
+function searchedFieldMarks(fieldNames, fields) {
+  const marks = new Uint8Array(fieldNames.length);
+  for (let fieldIndex = 0; fieldIndex < fieldNames.length; fieldIndex++) {
+    if (fields === void 0 || fields.includes(fieldNames[fieldIndex])) marks[fieldIndex] = 1;
+  }
+  return marks;
+}
+function searchFulltextMatches(state, params) {
+  const { queryTokens, termGroups, fields, tolerance = 0, prefixLength = 2, exact = false, filterBitset } = params;
+  const fieldNames = state.fieldNameTable.names;
+  const matched = createBitSet(state.docStore.internalIdCapacity());
+  const searched = searchedFieldMarks(fieldNames, fields);
+  const partial = partialFieldMarks(fieldNames, params.partialFields);
+  const searchedPartial = searched.map((mark, fieldIndex) => mark & partial[fieldIndex]);
+  for (const qt of queryTokens) {
+    const group = termGroupOf(termGroups, qt.token);
+    for (const match of typoMatchesFor(state.invertedIdx, qt.token, group, exact, tolerance, prefixLength)) {
+      markPostingList(matched, match.postingList, searched, filterBitset);
+    }
+    if (group === void 0) continue;
+    for (const member of group.members) {
+      const postingList = state.invertedIdx.lookup(member.token);
+      if (postingList === void 0) continue;
+      markPostingList(matched, postingList, member.factor > 0 ? searched : searchedPartial, filterBitset);
     }
   }
   const docStore = state.docStore;
@@ -3663,6 +3382,7 @@ function estimatePartitionBytes(state) {
   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();
+  bytes += state.partialWords.bytes();
   return bytes + sortColumnBytes(state);
 }
 
@@ -3794,10 +3514,71 @@ function mergeSegmentState(target, source) {
   mergeFieldIndexes(target, source, idMapping);
   mergeStatistics(target, source);
   mergeSurfaceForms(target, source);
+  target.partialWords.afterMerge(source.partialWords.spellings(), [...idMapping.values()]);
   target.sortColumns = null;
   target.scoreBuffer = null;
 }
 
+// src/core/partition/partial-words/platform.ts
+function platformPartialWordSearch() {
+  return partialWordSearchModule;
+}
+
+// src/core/partition/partial-words/registry.ts
+var registered2 = null;
+function isPartialWordSearchModule(value) {
+  return value !== null && typeof value === "object" && value.name === "partialWords" && "createGrowingSlot" in value && typeof value.createGrowingSlot === "function" && "createFrozenSlot" in value && typeof value.createFrozenSlot === "function" && "buildTable" in value && typeof value.buildTable === "function" && "expand" in value && typeof value.expand === "function";
+}
+function registerPartialWordSearch(module) {
+  if (!isPartialWordSearchModule(module)) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      'Pass registerPartialWordSearch the partialWordSearch object that "@delali/narsil/partial-words" exports'
+    );
+  }
+  registered2 = module;
+}
+function availablePartialWordSearch() {
+  return registered2 ?? platformPartialWordSearch();
+}
+function requirePartialWordSearchFor(schema) {
+  const fields = partialFieldsOf(schema);
+  if (fields.length === 0 || availablePartialWordSearch() !== null) return;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `The type of field "${fields[0]}" includes "partial", but this bundle contains no partial-word search code. Add import { partialWordSearch } from '@delali/narsil/partial-words', then call registerPartialWordSearch(partialWordSearch) before you create or load the index`,
+    { field: fields[0] }
+  );
+}
+var EMPTY_GROWING_SLOT = {
+  readerFor: () => null,
+  spellings: () => null,
+  bytes: () => 0,
+  afterDocument: () => void 0,
+  afterMerge: () => void 0,
+  forgetSpellings: () => void 0,
+  clear: () => void 0
+};
+var EMPTY_FROZEN_SLOT = {
+  readerFor: () => null,
+  spellings: () => null,
+  bytes: () => 0,
+  afterRemoval: () => void 0
+};
+function createGrowingPartialWords(view) {
+  return availablePartialWordSearch()?.createGrowingSlot(view) ?? EMPTY_GROWING_SLOT;
+}
+function createFrozenPartialWords(initial, tokenTable, documents) {
+  return availablePartialWordSearch()?.createFrozenSlot(initial, tokenTable, documents) ?? EMPTY_FROZEN_SLOT;
+}
+function buildPartialWordTableFrom(source, tokenTable) {
+  return availablePartialWordSearch()?.buildTable(source, tokenTable) ?? null;
+}
+function expandPartialWords(subs, analysis, requests) {
+  const module = availablePartialWordSearch();
+  return module === null ? requests.map(() => []) : module.expand(subs, analysis, requests);
+}
+
 // src/core/partition/rebuild.ts
 var EMPTY_STATS = {
   totalDocuments: 0,
@@ -3853,70 +3634,10 @@ function rebuildTextIndex(state, schema, language, options) {
     }
   } finally {
     state.invertedIdx.endBatch();
+    state.partialWords.forgetSpellings();
   }
 }
 
-// src/core/scorer.ts
-var DEFAULT_K1 = 1.2;
-var DEFAULT_B = 0.75;
-function computeIDF(docFrequency, totalDocs) {
-  if (totalDocs === 0) return 0;
-  return Math.log((totalDocs - docFrequency + 0.5) / (docFrequency + 0.5) + 1);
-}
-function bm25PruningSound(params) {
-  const k1 = params?.k1 ?? DEFAULT_K1;
-  const b = params?.b ?? DEFAULT_B;
-  return Number.isFinite(k1) && k1 >= 0 && b >= 0 && b <= 1;
-}
-function resolveBM25Params(params) {
-  return { k1: params?.k1 ?? DEFAULT_K1, b: params?.b ?? DEFAULT_B };
-}
-function computeBM25WithIDF(termFrequency, idf, fieldLength, avgFieldLength, k1, b) {
-  if (avgFieldLength === 0) return 0;
-  const numerator = termFrequency * (k1 + 1);
-  const denominator = termFrequency + k1 * (1 - b + b * fieldLength / avgFieldLength);
-  if (denominator === 0) return 0;
-  return idf * (numerator / denominator);
-}
-function computeBM25(termFrequency, docFrequency, totalDocs, fieldLength, avgFieldLength, params) {
-  if (totalDocs === 0) return 0;
-  const k1 = params?.k1 ?? DEFAULT_K1;
-  const b = params?.b ?? DEFAULT_B;
-  return computeBM25WithIDF(termFrequency, computeIDF(docFrequency, totalDocs), fieldLength, avgFieldLength, k1, b);
-}
-
-// src/core/partition/field-scoring.ts
-function loadFieldScoring(state, fields, boost, averageFieldLengths) {
-  const fieldNames = state.fieldNameTable.names;
-  const scoring = {
-    searchable: new Uint8Array(fieldNames.length),
-    boosts: new Float64Array(fieldNames.length),
-    averageLengths: new Float64Array(fieldNames.length),
-    lengthColumns: new Array(fieldNames.length).fill(null)
-  };
-  for (let fieldIndex = 0; fieldIndex < fieldNames.length; fieldIndex++) {
-    const fieldName = fieldNames[fieldIndex];
-    scoring.searchable[fieldIndex] = fields === void 0 || fields.includes(fieldName) ? 1 : 0;
-    scoring.boosts[fieldIndex] = boost?.[fieldName] ?? 1;
-    scoring.averageLengths[fieldIndex] = averageFieldLengths[fieldName] ?? 1;
-    scoring.lengthColumns[fieldIndex] = state.docStore.fieldLengthColumn(fieldName);
-  }
-  return scoring;
-}
-function fieldLengthOf(columns, fieldIndex, internalId, averageLength) {
-  const column = fieldIndex < columns.length ? columns[fieldIndex] : null;
-  if (column === null || internalId >= column.length) return averageLength;
-  const stored = column[internalId];
-  return stored > 0 ? stored : averageLength;
-}
-function bestSearchable(searchable, values) {
-  let best = 0;
-  for (let index = 0; index < searchable.length; index++) {
-    if (searchable[index] === 1 && values[index] > best) best = values[index];
-  }
-  return best;
-}
-
 // src/core/partition/block-bounds.ts
 var ABSENT_FIELD_LENGTH_BOUND = 0;
 var boundsByList = /* @__PURE__ */ new WeakMap();
@@ -4012,37 +3733,6 @@ function blockBoundsFor(list, columns) {
   return built;
 }
 
-// src/core/partition/scoring.ts
-var EMPTY_COMPONENTS = Object.freeze({});
-function recordComponents(components, internalId, fieldName, token, termFrequency, fieldLength, idf) {
-  const existing = components.get(internalId);
-  if (existing) {
-    existing.termFrequencies[`${fieldName}:${token}`] = termFrequency;
-    existing.fieldLengths[fieldName] = fieldLength;
-    existing.idf[token] = idf;
-    return;
-  }
-  components.set(internalId, {
-    termFrequencies: { [`${fieldName}:${token}`]: termFrequency },
-    fieldLengths: { [fieldName]: fieldLength },
-    idf: { [token]: idf }
-  });
-}
-function mergePrefixComponents(components, internalId, contribution) {
-  const existing = components.get(internalId);
-  if (existing) {
-    Object.assign(existing.termFrequencies, contribution.termFrequencies);
-    Object.assign(existing.fieldLengths, contribution.fieldLengths);
-    existing.idf[contribution.token] = contribution.idf;
-    return;
-  }
-  components.set(internalId, {
-    termFrequencies: contribution.termFrequencies,
-    fieldLengths: contribution.fieldLengths,
-    idf: { [contribution.token]: contribution.idf }
-  });
-}
-
 // src/core/partition/top-k-heap.ts
 function candidateWorse(a, b) {
   if (a.score !== b.score) return a.score < b.score;
@@ -4206,7 +3896,7 @@ function topKFromBuffer(buffer, k, resolver, components) {
 // src/core/partition/multi-term-topk.ts
 function prunableMultiTermLists(params, index) {
   if (params.queryTokens.length < 2) return null;
-  if (params.prefixExpansion !== void 0) return null;
+  if (params.termGroups !== void 0 && params.termGroups.length > 0) return null;
   if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
   if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
   if (params.collectComponents !== false) return null;
@@ -4378,87 +4068,6 @@ function multiTermTopK(request) {
   return { scored: pageFromBuffer(scans, buffer, selection, resolver), totalMatched };
 }
 
-// src/core/partition/prefix-scoring.ts
-function resolvePrefixMatches(context, token, expansionTerms) {
-  const found = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const term of [token, ...expansionTerms]) {
-    if (seen.has(term)) continue;
-    seen.add(term);
-    const postingList = context.index.lookup(term);
-    if (!postingList) continue;
-    found.push({ token: term, postingList, docFreq: context.documentFrequency(term, postingList) });
-  }
-  if (found.length === 0) return [];
-  let blendedDf = 0;
-  for (const f of found) {
-    if (f.docFreq > blendedDf) blendedDf = f.docFreq;
-  }
-  const blendedIdf = computeIDF(blendedDf, context.totalDocs);
-  return found.map((f) => ({
-    token: f.token,
-    factor: Math.min(1, token.length / f.token.length),
-    postingList: f.postingList,
-    docFreq: blendedDf,
-    idf: blendedIdf
-  }));
-}
-function computePrefixContributions(context, matches, collect) {
-  const { fields, fieldNames, filterBitset, k1, b } = context;
-  const scoresAreZero = context.totalDocs === 0;
-  const best = /* @__PURE__ */ new Map();
-  for (const match of matches) {
-    const perTerm = /* @__PURE__ */ new Map();
-    const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
-      match.postingList
-    );
-    for (let pi = 0; pi < count; pi++) {
-      const internalId = docIds[pi];
-      if (hasDeleted && deletedDocs.has(internalId)) continue;
-      if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-      const fieldIndex = fieldNameIndices[pi];
-      if (fields.searchable[fieldIndex] === 0) continue;
-      const fieldName = fieldNames[fieldIndex];
-      const termFrequency = termFrequencies[pi];
-      const fieldBoost = fields.boosts[fieldIndex];
-      const avgLen = fields.averageLengths[fieldIndex];
-      const actualFieldLength = fieldLengthOf(fields.lengthColumns, fieldIndex, internalId, avgLen);
-      const termScore = (scoresAreZero ? 0 : computeBM25WithIDF(termFrequency, match.idf, actualFieldLength, avgLen, k1, b)) * fieldBoost * match.factor;
-      const existing = perTerm.get(internalId);
-      if (existing) {
-        existing.score += termScore;
-        if (collect) {
-          existing.termFrequencies[`${fieldName}:${match.token}`] = termFrequency;
-          existing.fieldLengths[fieldName] = actualFieldLength;
-        }
-      } else if (collect) {
-        perTerm.set(internalId, {
-          score: termScore,
-          token: match.token,
-          idf: match.idf,
-          termFrequencies: { [`${fieldName}:${match.token}`]: termFrequency },
-          fieldLengths: { [fieldName]: actualFieldLength }
-        });
-      } else {
-        perTerm.set(internalId, {
-          score: termScore,
-          token: match.token,
-          idf: match.idf,
-          termFrequencies: EMPTY_COMPONENTS,
-          fieldLengths: EMPTY_COMPONENTS
-        });
-      }
-    }
-    for (const [internalId, contribution] of perTerm) {
-      const current = best.get(internalId);
-      if (!current || contribution.score > current.score) {
-        best.set(internalId, contribution);
-      }
-    }
-  }
-  return best;
-}
-
 // src/core/partition/single-term-topk.ts
 function fieldsCoverEvery(fields, fieldNames) {
   if (fields === void 0) return true;
@@ -4469,7 +4078,7 @@ function fieldsCoverEvery(fields, fieldNames) {
 }
 function prunableSingleTermList(params, index, fieldNames) {
   if (params.queryTokens.length !== 1) return null;
-  if (params.prefixExpansion !== void 0) return null;
+  if (params.termGroups !== void 0 && params.termGroups.length > 0) return null;
   if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
   if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
   if (params.collectComponents !== false) return null;
@@ -4579,15 +4188,11 @@ function singleTermTopK(request) {
 function globalDocFreqFor(docFreqs, term, fallback) {
   return Object.hasOwn(docFreqs, term) ? docFreqs[term] : fallback;
 }
-function matchesFor(index, token, exact, tolerance, prefixLength) {
-  if (!exact) return index.fuzzyLookup(token, tolerance, prefixLength);
-  const postingList = index.lookup(token);
-  return postingList ? [{ token, postingList }] : [];
-}
 function searchFulltext(state, params) {
   const {
     queryTokens,
-    prefixExpansion,
+    termGroups,
+    partialFields,
     fields,
     boost,
     tolerance = 0,
@@ -4619,19 +4224,75 @@ function searchFulltext(state, params) {
   function documentFrequency(token, list) {
     return globalStats ? globalDocFreqFor(globalStats.docFrequencies, token, list.docIdSet.size) : list.docIdSet.size;
   }
-  const prefixContext = {
+  const groupContext = {
     index: state.invertedIdx,
     fields: fieldScoring,
+    partialMarks: partialFieldMarks(fieldNames, partialFields),
     fieldNames,
     totalDocs,
     k1,
     b,
     filterBitset,
-    documentFrequency
+    globalFrequency(token) {
+      if (globalStats === void 0 || !Object.hasOwn(globalStats.docFrequencies, token)) return void 0;
+      return globalStats.docFrequencies[token];
+    }
   };
-  function mergePrefixContribution(internalId, contribution) {
+  function mergeGroupContribution(internalId, contribution) {
     addScore(scoreBuffer, internalId, contribution.score);
-    if (components !== null) mergePrefixComponents(components, internalId, contribution);
+    if (components !== null) mergeGroupComponents(components, internalId, contribution);
+  }
+  function resolveMatch(token, postingList) {
+    const docFreq = documentFrequency(token, postingList);
+    return { token, docFreq, idf: computeIDF(docFreq, totalDocs), postingList };
+  }
+  function scorePostings(match, onlyScored) {
+    const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+      match.postingList
+    );
+    if (!onlyScored && !hasDeleted && filterBitset === void 0 && components === null) {
+      for (let pi = 0; pi < count; pi++) {
+        const internalId = docIds[pi];
+        const fieldIndex = fieldNameIndices[pi];
+        if (searchable[fieldIndex] === 0) continue;
+        const avgLen = averageLengths[fieldIndex];
+        const actualFieldLength = fieldLengthOf(lengthColumns, fieldIndex, internalId, avgLen);
+        const termScore = scoresAreZero ? 0 : computeBM25WithIDF(termFrequencies[pi], match.idf, actualFieldLength, avgLen, k1, b);
+        addScore(scoreBuffer, internalId, termScore * boosts[fieldIndex]);
+      }
+      return;
+    }
+    for (let pi = 0; pi < count; pi++) {
+      const internalId = docIds[pi];
+      if (hasDeleted && deletedDocs.has(internalId)) continue;
+      if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
+      if (onlyScored && !hasScore(scoreBuffer, internalId)) continue;
+      const fieldIndex = fieldNameIndices[pi];
+      if (searchable[fieldIndex] === 0) continue;
+      const termFrequency = termFrequencies[pi];
+      const avgLen = averageLengths[fieldIndex];
+      const actualFieldLength = fieldLengthOf(lengthColumns, fieldIndex, internalId, avgLen);
+      const termScore = scoresAreZero ? 0 : computeBM25WithIDF(termFrequency, match.idf, actualFieldLength, avgLen, k1, b);
+      addScore(scoreBuffer, internalId, termScore * boosts[fieldIndex]);
+      if (components !== null) {
+        recordComponents(
+          components,
+          internalId,
+          fieldNames[fieldIndex],
+          match.token,
+          termFrequency,
+          actualFieldLength,
+          match.idf
+        );
+      }
+    }
+  }
+  function scoreGroup(group, onlyScored) {
+    if (group === null) return;
+    for (const [internalId, contribution] of computeGroupContributions(groupContext, group, collectComponents)) {
+      if (onlyScored && !hasScore(scoreBuffer, internalId)) continue;
+      mergeGroupContribution(internalId, contribution);
+    }
   }
   const prunableList = prunableSingleTermList(params, state.invertedIdx, fieldNames);
   if (prunableList !== null && maxResults !== void 0) {
@@ -4661,127 +4322,30 @@ function searchFulltext(state, params) {
   }
   if (useIntersection) {
     const resolved = [];
-    let prefixMatches = [];
     for (const qt of queryTokens) {
-      if (prefixExpansion && qt.token === prefixExpansion.token) {
-        prefixMatches = resolvePrefixMatches(prefixContext, qt.token, prefixExpansion.terms);
-        let totalPostings2 = 0;
-        for (const m of prefixMatches) {
-          totalPostings2 += m.postingList.length;
-        }
-        resolved.push({ token: qt.token, matches: [], totalPostings: totalPostings2, isPrefix: true });
-        continue;
-      }
-      const rawMatches = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
-      let totalPostings = 0;
+      const group = termGroupOf(termGroups, qt.token);
+      const groupMatches = group === void 0 ? null : resolveGroupMatches(groupContext, group);
+      let totalPostings = groupMatches === null ? 0 : groupPostingCount(groupMatches);
       const matches = [];
-      for (const m of rawMatches) {
-        const docFreq = documentFrequency(m.token, m.postingList);
-        const idf = computeIDF(docFreq, totalDocs);
+      for (const m of typoMatchesFor(state.invertedIdx, qt.token, group, exact, tolerance, prefixLength)) {
         totalPostings += m.postingList.length;
-        matches.push({ token: m.token, docFreq, idf, postingList: m.postingList });
+        matches.push(resolveMatch(m.token, m.postingList));
       }
-      resolved.push({ token: qt.token, matches, totalPostings });
+      resolved.push({ token: qt.token, matches, totalPostings, group: groupMatches });
     }
     resolved.sort((a, b2) => a.totalPostings - b2.totalPostings);
     for (let tokenIndex = 0; tokenIndex < resolved.length; tokenIndex++) {
-      if (resolved[tokenIndex].isPrefix) {
-        const contributions = computePrefixContributions(prefixContext, prefixMatches, collectComponents);
-        for (const [internalId, contribution] of contributions) {
-          if (tokenIndex > 0 && !hasScore(scoreBuffer, internalId)) continue;
-          mergePrefixContribution(internalId, contribution);
-        }
-        continue;
-      }
-      for (const match of resolved[tokenIndex].matches) {
-        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
-          match.postingList
-        );
-        for (let pi = 0; pi < count; pi++) {
-          const internalId = docIds[pi];
-          if (hasDeleted && deletedDocs.has(internalId)) continue;
-          if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-          if (tokenIndex > 0 && !hasScore(scoreBuffer, internalId)) continue;
-          const fieldIndex = fieldNameIndices[pi];
-          if (searchable[fieldIndex] === 0) continue;
-          const termFrequency = termFrequencies[pi];
-          const fieldBoost = boosts[fieldIndex];
-          const avgLen = averageLengths[fieldIndex];
-          const actualFieldLength = fieldLengthOf(lengthColumns, fieldIndex, internalId, avgLen);
-          let termScore = scoresAreZero ? 0 : computeBM25WithIDF(termFrequency, match.idf, actualFieldLength, avgLen, k1, b);
-          termScore *= fieldBoost;
-          addScore(scoreBuffer, internalId, termScore);
-          if (components !== null) {
-            recordComponents(
-              components,
-              internalId,
-              fieldNames[fieldIndex],
-              match.token,
-              termFrequency,
-              actualFieldLength,
-              match.idf
-            );
-          }
-        }
-      }
+      const onlyScored = tokenIndex > 0;
+      for (const match of resolved[tokenIndex].matches) scorePostings(match, onlyScored);
+      scoreGroup(resolved[tokenIndex].group, onlyScored);
     }
   } else {
     for (const qt of queryTokens) {
-      if (prefixExpansion && qt.token === prefixExpansion.token) {
-        const contributions = computePrefixContributions(
-          prefixContext,
-          resolvePrefixMatches(prefixContext, qt.token, prefixExpansion.terms),
-          collectComponents
-        );
-        for (const [internalId, contribution] of contributions) {
-          mergePrefixContribution(internalId, contribution);
-        }
-        continue;
-      }
-      const matchingPostings = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
-      for (const match of matchingPostings) {
-        const idf = computeIDF(documentFrequency(match.token, match.postingList), totalDocs);
-        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
-          match.postingList
-        );
-        if (!hasDeleted && filterBitset === void 0 && components === null) {
-          for (let pi = 0; pi < count; pi++) {
-            const internalId = docIds[pi];
-            const fieldIndex = fieldNameIndices[pi];
-            if (searchable[fieldIndex] === 0) continue;
-            const avgLen = averageLengths[fieldIndex];
-            const actualFieldLength = fieldLengthOf(lengthColumns, fieldIndex, internalId, avgLen);
-            const termScore = scoresAreZero ? 0 : computeBM25WithIDF(termFrequencies[pi], idf, actualFieldLength, avgLen, k1, b);
-            addScore(scoreBuffer, internalId, termScore * boosts[fieldIndex]);
-          }
-          continue;
-        }
-        for (let pi = 0; pi < count; pi++) {
-          const internalId = docIds[pi];
-          if (hasDeleted && deletedDocs.has(internalId)) continue;
-          if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-          const fieldIndex = fieldNameIndices[pi];
-          if (searchable[fieldIndex] === 0) continue;
-          const termFrequency = termFrequencies[pi];
-          const fieldBoost = boosts[fieldIndex];
-          const avgLen = averageLengths[fieldIndex];
-          const actualFieldLength = fieldLengthOf(lengthColumns, fieldIndex, internalId, avgLen);
-          let termScore = scoresAreZero ? 0 : computeBM25WithIDF(termFrequency, idf, actualFieldLength, avgLen, k1, b);
-          termScore *= fieldBoost;
-          addScore(scoreBuffer, internalId, termScore);
-          if (components !== null) {
-            recordComponents(
-              components,
-              internalId,
-              fieldNames[fieldIndex],
-              match.token,
-              termFrequency,
-              actualFieldLength,
-              idf
-            );
-          }
-        }
+      const group = termGroupOf(termGroups, qt.token);
+      for (const m of typoMatchesFor(state.invertedIdx, qt.token, group, exact, tolerance, prefixLength)) {
+        scorePostings(resolveMatch(m.token, m.postingList), false);
       }
+      if (group !== void 0) scoreGroup(resolveGroupMatches(groupContext, group), false);
     }
   }
   const totalMatched = scoreBuffer.touchedCount;
@@ -4931,7 +4495,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;
@@ -4990,6 +4554,7 @@ function encodeSegmentState(state) {
     totalFieldLengths: fieldLengths.totals,
     docFrequencies,
     surfaceForms: state.surfaceRegistry.size() === 0 ? null : state.surfaceRegistry.serialize(),
+    partialSpellings: state.partialWords.spellings(),
     ...encodeFieldIndexes(state, remap)
   };
 }
@@ -5108,6 +4673,8 @@ function mergeSegmentPayload(target, payload, documents) {
       target.surfaceRegistry.add(surface, value[1], value[0]);
     }
   }
+  const mergedIds = Array.from({ length: payload.docIds.length }, (_, at) => ordinalBase + at);
+  target.partialWords.afterMerge(payload.partialSpellings, mergedIds);
   target.sortColumns = null;
   target.scoreBuffer = null;
 }
@@ -5397,179 +4964,7 @@ function deserializePartition(state, data, clearFn, schema) {
   }
   loadPatternIndexes(state, data.fieldIndexes.pattern, schema);
   rebuildSizeIndexes(state, schema);
-}
-
-// src/core/partition/suggestions.ts
-function verbatimOccurrences(state, token) {
-  const postingList = state.invertedIdx.lookup(token);
-  if (!postingList) return 0;
-  const derived = postingList.totalTermFrequency - state.surfaceRegistry.stemChangedTotalFor(token);
-  return derived > 0 ? derived : 0;
-}
-function suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit) {
-  if (limit <= 0 || surfacePrefix.length === 0) return [];
-  const groups = /* @__PURE__ */ new Map();
-  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
-    const postingList = state.invertedIdx.lookup(candidate.token);
-    if (!postingList || postingList.docIdSet.size === 0) continue;
-    let group = groups.get(candidate.token);
-    if (!group) {
-      group = { documentFrequency: postingList.docIdSet.size, surfaces: [] };
-      groups.set(candidate.token, group);
-    }
-    group.surfaces.push({ surface: candidate.surface, occurrences: candidate.occurrences });
-  }
-  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedPrefix !== surfacePrefix && stemmedPrefix.length > 0 ? [surfacePrefix, stemmedPrefix] : [surfacePrefix];
-  for (const prefix of termPrefixes) {
-    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
-      const occurrences = verbatimOccurrences(state, suggestion.term);
-      if (occurrences === 0) continue;
-      let group = groups.get(suggestion.term);
-      if (!group) {
-        group = { documentFrequency: suggestion.documentFrequency, surfaces: [] };
-        groups.set(suggestion.term, group);
-      } else if (group.surfaces.some((s) => s.surface === suggestion.term)) {
-        continue;
-      }
-      group.surfaces.push({ surface: suggestion.term, occurrences });
-    }
-  }
-  const results = [];
-  for (const [token, group] of groups) {
-    results.push({ token, documentFrequency: group.documentFrequency, surfaces: group.surfaces });
-  }
-  results.sort((a, b) => b.documentFrequency - a.documentFrequency || 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;
-  }
-  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) ?? ""
-    }));
-  }
-  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,
-      ...patternIndexesToWire(serializePatternIndexes(state, schema))
-    },
-    surface_forms: state.surfaceRegistry.serialize(),
-    statistics: {
-      total_documents: serializedStats.totalDocuments,
-      total_field_lengths: serializedStats.totalFieldLengths,
-      average_field_lengths: serializedStats.averageFieldLengths,
-      doc_frequencies: serializedStats.docFrequencies
-    }
-  };
+  state.partialWords.forgetSpellings();
 }
 
 // src/core/partition/index.ts
@@ -5586,9 +4981,10 @@ function partitionStateOf(partition) {
 }
 function createPartitionIndex(partitionId, trackPositions = true) {
   const fieldNameTable = { names: [], indexMap: /* @__PURE__ */ new Map() };
+  const docStore = createDocumentStore();
   const state = {
     invertedIdx: createInvertedIndex(fieldNameTable),
-    docStore: createDocumentStore(),
+    docStore,
     stats: createPartitionStats(),
     surfaceRegistry: createSurfaceRegistry(),
     numericIndexes: /* @__PURE__ */ new Map(),
@@ -5598,6 +4994,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     patternIndexes: /* @__PURE__ */ new Map(),
     sizeIndexes: /* @__PURE__ */ new Map(),
     fieldNameTable,
+    partialWords: createGrowingPartialWords({ docStore }),
     flatSchemaCache: null,
     lastSchemaRef: null,
     trackPositions,
@@ -5618,6 +5015,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     state.geoIndexes.clear();
     state.patternIndexes.clear();
     state.sizeIndexes.clear();
+    state.partialWords.clear();
     state.stats.deserialize({ totalDocuments: 0, totalFieldLengths: {}, averageFieldLengths: {}, docFrequencies: {} });
     state.flatSchemaCache = null;
     state.lastSchemaRef = null;
@@ -5646,7 +5044,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
         }
       }
       const internalId = state.docStore.ensureInternalId(docId);
-      const { fieldLengths, tokensByField } = indexDocument(
+      const { fieldLengths, tokensByField, partialSpellings } = indexDocument(
         state,
         docId,
         document,
@@ -5660,6 +5058,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
         state.docStore.store(docId, document, fieldLengths);
       }
       state.stats.addDocument(fieldLengths, tokensByField);
+      state.partialWords.afterDocument(partialFieldsOf(schema), internalId, partialSpellings, 1);
       recordSortValues(state, internalId, document);
     },
     remove(docId, schema, language, options) {
@@ -5670,7 +5069,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
           partitionId
         });
       }
-      const { fieldLengths, tokensByField } = removeFromIndexes(
+      const { fieldLengths, tokensByField, partialSpellings } = removeFromIndexes(
         state,
         docId,
         stored,
@@ -5681,6 +5080,9 @@ function createPartitionIndex(partitionId, trackPositions = true) {
       const internalId = state.docStore.getInternalId(docId);
       state.docStore.remove(docId);
       state.stats.removeDocument(fieldLengths, tokensByField);
+      if (internalId !== void 0) {
+        state.partialWords.afterDocument(partialFieldsOf(schema), internalId, partialSpellings, -1);
+      }
       forgetSortValues(state, internalId);
     },
     beginBatch() {
@@ -5716,29 +5118,19 @@ function createPartitionIndex(partitionId, trackPositions = true) {
       const fields = schemaFieldsOf(schema);
       const needsTextReindex = textFieldsChanged(stored.fields, document, fields);
       if (needsTextReindex) {
-        const { fieldLengths: oldFieldLengths, tokensByField: oldTokens } = removeFromIndexes(
-          state,
-          docId,
-          stored,
-          fields,
-          language,
-          options
-        );
-        state.stats.removeDocument(oldFieldLengths, oldTokens);
+        const previous = removeFromIndexes(state, docId, stored, fields, language, options);
+        state.stats.removeDocument(previous.fieldLengths, previous.tokensByField);
         const previousInternalId = state.docStore.getInternalId(docId);
+        if (previousInternalId !== void 0) {
+          state.partialWords.afterDocument(partialFieldsOf(schema), previousInternalId, previous.partialSpellings, -1);
+        }
         state.docStore.remove(docId);
         forgetSortValues(state, previousInternalId);
         const internalId = state.docStore.ensureInternalId(docId);
-        const { fieldLengths: newFieldLengths, tokensByField: newTokens } = indexDocument(
-          state,
-          docId,
-          document,
-          fields,
-          language,
-          options
-        );
-        state.docStore.store(docId, document, newFieldLengths);
-        state.stats.addDocument(newFieldLengths, newTokens);
+        const next = indexDocument(state, docId, document, fields, language, options);
+        state.docStore.store(docId, document, next.fieldLengths);
+        state.stats.addDocument(next.fieldLengths, next.tokensByField);
+        state.partialWords.afterDocument(partialFieldsOf(schema), internalId, next.partialSpellings, 1);
         recordSortValues(state, internalId, document);
       } else {
         updateFieldIndexOnly(state, docId, stored.fields, document, fields);
@@ -5809,15 +5201,17 @@ function createPartitionIndex(partitionId, trackPositions = true) {
       return suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit);
     },
     expandTermPrefix(surfacePrefix, stemmedToken, maxExpansions) {
-      return expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions);
+      return expandTermPrefix([state], surfacePrefix, stemmedToken, maxExpansions);
+    },
+    expandPartialWords(analysis, requests) {
+      return expandPartialWords([state], analysis, requests);
+    },
+    preparePartialWords(analysis) {
+      expandPartialWords([state], analysis, []);
     },
     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);
     }
@@ -5847,7 +5241,7 @@ function frozenSegmentBytes(segment) {
     bytes += entry.docIds.byteLength + entry.latitudes.byteLength + entry.longitudes.byteLength;
   }
   for (const reader of segment.patternIndexes.values()) bytes += reader.bytes();
-  return bytes;
+  return bytes + segment.partialWords.bytes();
 }
 
 // src/core/partition/composite/compaction.ts
@@ -5982,20 +5376,19 @@ function subMatchesView(matches, layout, subIndex) {
 
 // src/core/partition/composite/stats.ts
 function collectCandidateTerms(subs, params) {
-  const { queryTokens, prefixExpansion, tolerance = 0, prefixLength = 2, exact = false } = params;
+  const { queryTokens, termGroups, tolerance = 0, prefixLength = 2, exact = false } = params;
   const terms = /* @__PURE__ */ new Set();
   for (const qt of queryTokens) {
-    if (prefixExpansion && qt.token === prefixExpansion.token) {
-      terms.add(qt.token);
-      for (const term of prefixExpansion.terms) terms.add(term);
-      continue;
+    const group = termGroupOf(termGroups, qt.token);
+    if (group !== void 0) {
+      for (const member of group.members) terms.add(member.token);
     }
-    if (exact || tolerance === 0) {
+    if (group === void 0 && (exact || tolerance === 0)) {
       terms.add(qt.token);
       continue;
     }
     for (const sub of subs) {
-      for (const match of sub.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength)) {
+      for (const match of typoMatchesFor(sub.invertedIdx, qt.token, group, exact, tolerance, prefixLength)) {
         terms.add(match.token);
       }
     }
@@ -6005,11 +5398,7 @@ function collectCandidateTerms(subs, params) {
 function resolveQueryTermFrequencies(subs, params) {
   const frequencies = /* @__PURE__ */ Object.create(null);
   for (const term of collectCandidateTerms(subs, params)) {
-    let total = 0;
-    for (const sub of subs) {
-      const list = sub.invertedIdx.lookup(term);
-      if (list !== void 0) total += list.docIdSet.size;
-    }
+    const total = partitionDocumentFrequency(subs, term);
     if (total > 0) frequencies[term] = total;
   }
   return frequencies;
@@ -6195,9 +5584,10 @@ function compositeSortValues(subs, docId, fields, fieldTypes, modes) {
 
 // src/core/partition/composite/suggest.ts
 function compositeSuggestTerms(subs, surfacePrefix, stemmedPrefix, limit) {
+  if (limit <= 0) return [];
   const merged = /* @__PURE__ */ new Map();
   for (const sub of subs) {
-    for (const suggestion of suggestDisplayTerms(sub, surfacePrefix, stemmedPrefix, limit)) {
+    for (const suggestion of suggestDisplayTerms(sub, surfacePrefix, stemmedPrefix, Number.MAX_SAFE_INTEGER)) {
       let entry = merged.get(suggestion.token);
       if (entry === void 0) {
         entry = { documentFrequency: 0, surfaceOccurrences: /* @__PURE__ */ new Map() };
@@ -6222,19 +5612,6 @@ function compositeSuggestTerms(subs, surfacePrefix, stemmedPrefix, limit) {
   if (suggestions.length > limit) suggestions.length = limit;
   return suggestions;
 }
-function compositeExpandTermPrefix(subs, surfacePrefix, stemmedToken, maxExpansions) {
-  const expansions = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const sub of subs) {
-    for (const term of expandTermPrefix(sub, surfacePrefix, stemmedToken, maxExpansions)) {
-      if (seen.has(term)) continue;
-      seen.add(term);
-      expansions.push(term);
-      if (expansions.length === maxExpansions) return expansions;
-    }
-  }
-  return expansions;
-}
 
 // src/core/partition/composite/index.ts
 function isCompositePartition(partition) {
@@ -6340,10 +5717,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();
@@ -6442,7 +5815,13 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       return compositeSuggestTerms(subs(), surfacePrefix, stemmedPrefix, limit);
     },
     expandTermPrefix(surfacePrefix, stemmedToken, maxExpansions) {
-      return compositeExpandTermPrefix(subs(), surfacePrefix, stemmedToken, maxExpansions);
+      return expandTermPrefix(subs(), surfacePrefix, stemmedToken, maxExpansions);
+    },
+    expandPartialWords(analysis, requests) {
+      return expandPartialWords(subs(), analysis, requests);
+    },
+    preparePartialWords(analysis) {
+      expandPartialWords(subs(), analysis, []);
     },
     get(docId, projection) {
       const owner = frozenOwner(docId);
@@ -6503,6 +5882,11 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
 }
 
 // src/partitioning/insert-options.ts
+function resolvePartialWordAnalysis(config, language, analysis) {
+  const fields = partialFieldsOf(config.schema);
+  if (fields.length === 0) return null;
+  return { fields, language, options: resolvePartitionInsertOptions(config, analysis) };
+}
 function resolvePartitionInsertOptions(config, analysis, options) {
   const applyStrict = config.strict === true;
   const applyAnalyzer = analysis.stopWords !== void 0 || analysis.customTokenizer !== void 0;
@@ -6561,8 +5945,10 @@ function createCapacityChecks(source) {
 // src/partitioning/manager/index.ts
 function createPartitionManager(indexName, config, language, router, initialPartitionCount, vectorIndexes) {
   requirePatternSearchFor(config.schema);
+  requirePartialWordSearchFor(config.schema);
   const count = initialPartitionCount ?? 1;
   const analysis = resolveIndexAnalysis(config);
+  const partialWordAnalysis = resolvePartialWordAnalysis(config, language, analysis);
   const trackPositions = config.trackPositions ?? true;
   const vecIndexes = vectorIndexes ?? /* @__PURE__ */ new Map();
   let partitions = [];
@@ -6582,6 +5968,9 @@ function createPartitionManager(indexName, config, language, router, initialPart
   function resolveInsertOptions(options) {
     return resolvePartitionInsertOptions(config, analysis, options);
   }
+  function preparePartialWords(partitionId) {
+    if (partialWordAnalysis !== null) partitions[partitionId].preparePartialWords(partialWordAnalysis);
+  }
   function locateDocument(docId) {
     return docPartitionMap.get(docId);
   }
@@ -6637,6 +6026,9 @@ function createPartitionManager(indexName, config, language, router, initialPart
     get analysis() {
       return analysis;
     },
+    get partialWordAnalysis() {
+      return partialWordAnalysis;
+    },
     getPartition(partitionId) {
       validatePartitionId(partitionId);
       return partitions[partitionId];
@@ -6713,6 +6105,7 @@ function createPartitionManager(indexName, config, language, router, initialPart
     rebuildTextIndex(partitionId) {
       validatePartitionId(partitionId);
       partitions[partitionId].rebuildTextIndex(config.schema, language, resolveInsertOptions());
+      preparePartialWords(partitionId);
     },
     beginBatchRemove() {
       for (let i = 0; i < partitions.length; i++) {
@@ -6774,10 +6167,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];
@@ -6818,6 +6207,7 @@ function createPartitionManager(indexName, config, language, router, initialPart
     deserializePartition(partitionId, data) {
       validatePartitionId(partitionId);
       partitions[partitionId].deserialize(data, config.schema);
+      preparePartialWords(partitionId);
       rebuildDocPartitionMapForPartition(partitionId);
     },
     getAggregateStats() {
@@ -6903,6 +6293,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;
 
@@ -6962,7 +6355,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;
   }
@@ -7083,14 +6476,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/";
@@ -7855,6 +7240,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;
@@ -7881,7 +7272,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) {
@@ -7911,9 +7302,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")) {
@@ -7952,6 +7343,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) {
@@ -8002,14 +7395,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");
@@ -8030,7 +7425,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
@@ -8060,36 +7504,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;
@@ -8128,36 +7542,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;
@@ -8210,7 +7594,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;
@@ -8233,14 +7617,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);
     }
   }
@@ -8279,6 +7663,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);
@@ -8318,10 +7713,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);
@@ -8369,13 +7764,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;
@@ -8400,18 +7796,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,
@@ -8421,12 +7818,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);
     }
   };
@@ -8446,13 +7843,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;
@@ -8463,17 +7869,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);
@@ -9154,12 +8552,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);
@@ -9277,11 +8674,55 @@ 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* storedDocumentsOf(data) {
+  const count = data.offsets.length - 1;
+  for (let ordinal = 0; ordinal < count; ordinal++) {
+    yield decodeStoredDocument(
+      data.blob.subarray(data.offsets[ordinal], data.offsets[ordinal + 1]),
+      data.discardedFields
+    );
+  }
+}
+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;
   }
@@ -9309,11 +8750,14 @@ 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);
       }
       return document;
+    },
+    readAt(ordinal) {
+      return decoded[ordinal] ?? decodeStoredDocument(blob.subarray(offsets[ordinal], offsets[ordinal + 1]), data.discardedFields);
     }
   };
 }
@@ -9327,75 +8771,15 @@ function wrapDocumentArray(documents) {
     byteLength: residentBytes,
     docAt(ordinal) {
       return documents[ordinal];
+    },
+    readAt(ordinal) {
+      return documents[ordinal];
     }
   };
 }
 
-// src/core/partition/frozen/string-blob.ts
-var SURROGATE = /[\ud800-\udfff]/;
-var encoder = new TextEncoder();
-function encodeOneByOne(strings) {
-  const encoded = new Array(strings.length);
-  let blobLength = 0;
-  for (let i = 0; i < strings.length; i++) {
-    encoded[i] = encoder.encode(strings[i]);
-    blobLength += encoded[i].length;
-  }
-  const blob = new Uint8Array(blobLength);
-  const offsets = new Uint32Array(strings.length + 1);
-  let cursor = 0;
-  for (let i = 0; i < strings.length; i++) {
-    blob.set(encoded[i], cursor);
-    cursor += encoded[i].length;
-    offsets[i + 1] = cursor;
-  }
-  return { blob, offsets };
-}
-function basicPlaneUtf8Bytes(text) {
-  let bytes = text.length;
-  for (let i = 0; i < text.length; i++) {
-    const unit = text.charCodeAt(i);
-    if (unit >= 128) bytes += unit < 2048 ? 1 : 2;
-  }
-  return bytes;
-}
-function encodeStringBlob(strings) {
-  const joined = strings.join("");
-  if (SURROGATE.test(joined)) return encodeOneByOne(strings);
-  const blob = encoder.encode(joined);
-  const offsets = new Uint32Array(strings.length + 1);
-  let cursor = 0;
-  for (let i = 0; i < strings.length; i++) {
-    cursor += basicPlaneUtf8Bytes(strings[i]);
-    offsets[i + 1] = cursor;
-  }
-  return cursor === blob.length ? { blob, offsets } : encodeOneByOne(strings);
-}
-function orderByComparator(strings) {
-  const order = new Array(strings.length);
-  for (let i = 0; i < strings.length; i++) order[i] = i;
-  return order.sort((a, b) => compareCodePoints(strings[a], strings[b]));
-}
-function alreadyInCodePointOrder(strings) {
-  for (let i = 1; i < strings.length; i++) {
-    if (compareCodePoints(strings[i - 1], strings[i]) > 0) return false;
-  }
-  return true;
-}
-function codePointOrder(strings) {
-  if (alreadyInCodePointOrder(strings)) return strings.map((_, i) => i);
-  if (SURROGATE.test(strings.join(""))) return orderByComparator(strings);
-  const positions = /* @__PURE__ */ new Map();
-  for (let i = 0; i < strings.length; i++) positions.set(strings[i], i);
-  if (positions.size !== strings.length) return orderByComparator(strings);
-  const order = new Array(strings.length);
-  const sorted = [...strings].sort();
-  for (let i = 0; i < sorted.length; i++) order[i] = positions.get(sorted[i]) ?? 0;
-  return order;
-}
-
 // src/core/partition/frozen/external-ids.ts
-var encoder2 = new TextEncoder();
+var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 function encodeExternalIdTableData(docIds) {
   const { blob, offsets } = encodeStringBlob(docIds);
@@ -9427,7 +8811,7 @@ function wrapExternalIdTable(data) {
     bytes: blob.byteLength + offsets.byteLength + sortedOrdinals.byteLength,
     idAt,
     ordinalOf(docId) {
-      const query = encoder2.encode(docId);
+      const query = encoder.encode(docId);
       let lo = 0;
       let hi = count;
       while (lo < hi) {
@@ -9713,6 +9097,10 @@ function createFrozenInvertedReader(table, views) {
       if (at < 0) return void 0;
       return views.viewReadOnce(table.payloadSlot(at), table.documentFrequencyAt(at));
     },
+    documentFrequency(token) {
+      const at = table.find(token);
+      return at < 0 ? 0 : table.documentFrequencyAt(at);
+    },
     fuzzyLookup(token, tolerance, prefixLength) {
       if (tolerance === 0) {
         const at = table.find(token);
@@ -9867,7 +9255,7 @@ function createLazySurfaceReader(load) {
 }
 
 // src/core/partition/frozen/token-table.ts
-var encoder3 = new TextEncoder();
+var encoder2 = new TextEncoder();
 var decoder3 = new TextDecoder();
 function compareBytes2(blob, start, end, query) {
   const length = end - start;
@@ -9931,7 +9319,7 @@ function wrapFrozenTokenTable(data) {
     size,
     bytes: blob.byteLength + offsets.byteLength + payloadSlots.byteLength + documentFrequencies.byteLength,
     find(token) {
-      const query = encoder3.encode(token);
+      const query = encoder2.encode(token);
       const at = lowerBound3(query);
       if (at >= size) return -1;
       return compareBytes2(blob, offsets[at], offsets[at + 1], query) === 0 ? at : -1;
@@ -9944,6 +9332,9 @@ function wrapFrozenTokenTable(data) {
       }
       return token;
     },
+    byteLengthAt(sortedIndex) {
+      return offsets[sortedIndex + 1] - offsets[sortedIndex];
+    },
     payloadSlot(sortedIndex) {
       return payloadSlots[sortedIndex];
     },
@@ -9951,7 +9342,7 @@ function wrapFrozenTokenTable(data) {
       return documentFrequencies[sortedIndex];
     },
     prefixRange(prefix) {
-      const bytes = encoder3.encode(prefix);
+      const bytes = encoder2.encode(prefix);
       const start = lowerBound3(bytes);
       return { start, end: prefixEnd(start, bytes) };
     },
@@ -9969,8 +9360,8 @@ function wrapFrozenTokenTable(data) {
         fromCodePoint = unit;
         toCodePoint = nextCodePoint(unit);
       }
-      const from = encoder3.encode(String.fromCodePoint(fromCodePoint));
-      const to = encoder3.encode(String.fromCodePoint(toCodePoint));
+      const from = encoder2.encode(String.fromCodePoint(fromCodePoint));
+      const to = encoder2.encode(String.fromCodePoint(toCodePoint));
       return { start: lowerBound3(from), end: lowerBound3(to) };
     }
   };
@@ -10032,11 +9423,68 @@ function sharedSurfaceTable(payload) {
   if (table.counts.length === 0) return null;
   return { blob: sharedUint8(table.blob), offsets: sharedUint32(table.offsets), counts: sharedUint32(table.counts) };
 }
-function freezeSegmentShared(payload, documents, segmentId) {
+function sharePartialWordTable(table) {
+  if (typeof SharedArrayBuffer !== "function") return table;
+  return {
+    fields: [...table.fields],
+    spellings: sharedUint8(table.spellings),
+    spellingOffsets: sharedUint32(table.spellingOffsets),
+    spellingTokens: sharedUint32(table.spellingTokens),
+    spellingCounts: sharedUint32(table.spellingCounts),
+    runs: sharedUint32(table.runs),
+    runOffsets: sharedUint32(table.runOffsets),
+    runEntries: sharedUint32(table.runEntries)
+  };
+}
+function sharedPartialWordsOf(tokenData, spellings, documentData, analysis) {
+  let source = spellings;
+  if (source === null && analysis !== null && analysis.fields.length > 0) {
+    source = encodePartialSpellings(analysis.fields, spellingCountsOf(storedDocumentsOf(documentData), analysis));
+  }
+  if (source === null || source.fields.length === 0) return null;
+  const table = buildPartialWordTableFrom(source, wrapFrozenTokenTable(tokenData));
+  return table === null ? null : sharePartialWordTable(table);
+}
+function shareSegmentArrays(arrays, analysis, segmentId) {
+  return {
+    ...arrays,
+    segmentId: segmentId ?? generateId(),
+    partialWords: sharedPartialWordsOf(arrays.tokenTable, null, arrays.documentTable, analysis)
+  };
+}
+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, analysis = null) {
   if (typeof SharedArrayBuffer !== "function") return null;
-  return freezeEncodedSegmentShared(payload, encodeDocumentTableData(documents), segmentId);
+  return freezeEncodedSegmentShared(payload, encodeDocumentTableData(documents), segmentId, analysis);
 }
-function freezeEncodedSegmentShared(payload, documentData, segmentId) {
+function freezeEncodedSegmentShared(payload, documentData, segmentId, analysis = null) {
   if (typeof SharedArrayBuffer !== "function") return null;
   const tokenData = encodeFrozenTokenTableData(payload.tokens, payload.docFrequencies);
   const idData = encodeExternalIdTableData(payload.docIds);
@@ -10060,12 +9508,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) => ({
@@ -10102,7 +9551,8 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
       offsets: sharedUint32(entry.offsets),
       postings: sharedUint32(entry.postings)
     })),
-    surfaceTable: sharedSurfaceTable(payload)
+    surfaceTable: sharedSurfaceTable(payload),
+    partialWords: sharedPartialWordsOf(tokenData, payload.partialSpellings, documentData, analysis)
   };
 }
 
@@ -10138,7 +9588,12 @@ function buildGeoReaders(entries) {
   }
   return readers;
 }
-function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot) {
+function* survivingDocuments(documentSource, tombstones) {
+  for (let ordinal = 0; ordinal < documentSource.count; ordinal++) {
+    if (!tombstones.has(ordinal)) yield documentSource.readAt(ordinal);
+  }
+}
+function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot, partialWordTable) {
   const tombstones = createFrozenTombstones();
   const postingViews = createFrozenPostingViews(source, tombstones);
   const lengthColumns = /* @__PURE__ */ new Map();
@@ -10146,6 +9601,10 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     lengthColumns.set(source.fieldLengthNames[i], source.fieldLengthColumns[i]);
   }
   const docStore = createFrozenDocTable(source.idTable, lengthColumns, documentSource, tombstones);
+  const partialWords = createFrozenPartialWords(partialWordTable, source.tokenTable, {
+    documentAt: (ordinal) => documentSource.readAt(ordinal),
+    survivors: () => survivingDocuments(documentSource, tombstones)
+  });
   const numericIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.numeric) numericIndexes.set(entry.fieldPath, createFrozenNumericReader(entry));
   const sizeIndexes = /* @__PURE__ */ new Map();
@@ -10178,6 +9637,7 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     patternIndexes,
     sizeIndexes,
     fieldNameTable,
+    partialWords,
     trackPositions: source.positionOffsets !== null,
     flatSchemaCache: null,
     lastSchemaRef: null,
@@ -10197,6 +9657,7 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
       if (ordinal === void 0) return false;
       const added = tombstones.add(ordinal);
       if (added) {
+        partialWords.afterRemoval(ordinal);
         docStore.releaseSortedDocIds();
         segment.sortColumns = null;
         segment.scoreBuffer = null;
@@ -10212,18 +9673,20 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
   return segment;
 }
 function createFrozenSegment(payload, documents, segmentId) {
+  const tokenTable = buildFrozenTokenTable(payload.tokens, payload.docFrequencies);
   return assembleFrozenSegment(
     segmentId ?? generateId(),
     {
       ...payload,
-      tokenTable: buildFrozenTokenTable(payload.tokens, payload.docFrequencies),
+      tokenTable,
       idTable: buildExternalIdTable(payload.docIds),
       documentTable: null,
       readSurfaceForms: () => payload.surfaceForms,
       docFrequencies: () => payload.docFrequencies
     },
     wrapDocumentArray(documents),
-    null
+    null,
+    payload.partialSpellings === null ? null : buildPartialWordTableFrom(payload.partialSpellings, tokenTable)
   );
 }
 function createSharedFrozenSegment(snapshot) {
@@ -10245,9 +9708,137 @@ function createSharedFrozenSegment(snapshot) {
       }
     },
     wrapEncodedDocumentTable(snapshot.documentTable),
-    snapshot
+    snapshot,
+    snapshot.partialWords
   );
 }
+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) {
@@ -10510,7 +10101,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;
@@ -10584,11 +10175,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));
   }
@@ -10601,7 +10196,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]);
   }
@@ -10647,20 +10242,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);
@@ -10682,14 +10291,18 @@ function mergeDocuments2(inputs, documentCount) {
   }
   return { blob, offsets };
 }
-function mergeFrozenSegments(segments) {
+function mergeFrozenSegments(segments, analysis) {
   if (typeof SharedArrayBuffer !== "function") return null;
+  const merged = mergeSegmentContents(segments.map((segment) => ({ segment })));
+  return freezeEncodedSegmentShared(merged.payload, merged.documents, void 0, analysis);
+}
+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);
@@ -10710,9 +10323,10 @@ function mergeFrozenSegments(segments) {
     totalFieldLengths: lengths.totalFieldLengths,
     docFrequencies: postings.docFrequencies,
     surfaceForms: mergeSurfaceForms2(inputs),
+    partialSpellings: null,
     ...mergeFieldIndexes2(inputs)
   };
-  return freezeEncodedSegmentShared(payload, mergeDocuments2(inputs, documentCount));
+  return { payload, documents: mergeDocuments2(inputs, documentCount) };
 }
 
 // src/core/partition/segment-postings.ts
@@ -10826,7 +10440,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]]++;
@@ -10980,14 +10594,18 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
     patternIndexes: /* @__PURE__ */ new Map(),
     sizeIndexes: /* @__PURE__ */ new Map()
   };
+  const partialFields = partialFieldsOf(schema);
+  const spellings = /* @__PURE__ */ new Map();
+  let fieldSpellings = null;
   let positionOffset = 0;
   const addToken = (token, position, surface) => {
     postings.addToken(token, positionOffset + position);
     surfaces.count(surface, token);
+    if (fieldSpellings !== null) countSpelling(fieldSpellings, token, surface ?? token, 1);
   };
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
     const document = documents[ordinal].document;
-    for (const { path: fieldPath, base: fieldType, pattern } of fields) {
+    for (const { path: fieldPath, base: fieldType, pattern, partial } of fields) {
       const value = getNestedValue(document, fieldPath);
       if (value === void 0 || value === null) continue;
       recordValueSize(filters.sizeIndexes, ordinal, fieldPath, fieldType, value);
@@ -10996,6 +10614,7 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
         indexFilterValue(filters, ordinal, fieldPath, fieldType, value);
         continue;
       }
+      fieldSpellings = partial ? spellings : null;
       postings.beginField();
       positionOffset = 0;
       for (const text of fieldType === "string" ? [value] : value) {
@@ -11016,6 +10635,7 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
     fieldLengthColumns: lengths.columns,
     totalFieldLengths: lengths.totalsByName(),
     surfaceForms: surfaces.encode(),
+    partialSpellings: partialFields.length === 0 ? null : encodePartialSpellings(partialFields, spellings),
     ...encodeFieldIndexes(filters, identity)
   };
 }
@@ -11082,7 +10702,7 @@ function runSegmentAction(entry, action) {
     }
     case "compactSegments": {
       const partition = requireComposite(entry, action.indexName, action.partitionId, "compact");
-      return mergeFrozenSegments(partition.frozenSegmentsById(action.segmentIds));
+      return mergeFrozenSegments(partition.frozenSegmentsById(action.segmentIds), entry.manager.partialWordAnalysis);
     }
     case "swapSegments": {
       requireComposite(entry, action.indexName, action.partitionId, "swap");
@@ -11559,4 +11179,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, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, 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, registerPartialWordSearch, registerPatternSearch, registerStopWords, registerTokenizer, requirePartialWordSearchFor, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, shareSegmentArrays, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };