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

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

@@ -1,10 +1,14 @@
+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 { tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, everyValueFacetConfig, mergeFacets, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-3YKWSO54.mjs';
-import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, MAX_DOC_ID_LENGTH, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-AK3BLGCI.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, requireWholeNeighbourLists, topLayerInParts, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-WVDFG45M.mjs';
-import { MAX_M, noteFallback, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-PU43WDY4.mjs';
+import { 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 { 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';
@@ -411,8 +415,6 @@ function compactList(list) {
         }
       }
       writeIdx++;
-    } else {
-      list.totalTermFrequency -= list.termFrequencies[i];
     }
   }
   list.docIds.length = writeIdx;
@@ -437,8 +439,6 @@ function compactDocEntries(list, internalId) {
         }
       }
       writeIdx++;
-    } else {
-      list.totalTermFrequency -= list.termFrequencies[i];
     }
   }
   list.docIds.length = writeIdx;
@@ -524,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);
@@ -562,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);
@@ -1667,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);
@@ -1676,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) {
@@ -1685,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);
@@ -1701,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);
@@ -1711,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);
@@ -1721,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);
@@ -1740,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;
@@ -1755,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;
@@ -1767,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") {
@@ -1796,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);
@@ -1811,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);
@@ -1827,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") {
@@ -1849,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[]") {
@@ -1882,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
@@ -3017,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;
@@ -3030,39 +3127,174 @@ function postingColumns(list) {
   };
 }
 
+// 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 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, fieldNames, fields, filterBitset) {
+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 (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) 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, prefixExpansion, fields, tolerance = 0, prefixLength = 2, exact = false, filterBitset } = 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) {
-    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;
+    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);
     }
-    for (const match of state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength)) {
-      markPostingList(matched, match.postingList, fieldNames, fields, 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;
@@ -3150,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);
 }
 
@@ -3281,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,
@@ -3340,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();
@@ -3499,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;
@@ -3693,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;
@@ -3865,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;
@@ -3956,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;
@@ -4066,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,
@@ -4106,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) {
@@ -4148,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;
@@ -4477,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)
   };
 }
@@ -4595,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;
 }
@@ -4884,72 +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]);
+  state.partialWords.forgetSpellings();
 }
 
 // src/core/partition/index.ts
@@ -4966,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(),
@@ -4978,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,
@@ -4998,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;
@@ -5026,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,
@@ -5040,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) {
@@ -5050,7 +5069,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
           partitionId
         });
       }
-      const { fieldLengths, tokensByField } = removeFromIndexes(
+      const { fieldLengths, tokensByField, partialSpellings } = removeFromIndexes(
         state,
         docId,
         stored,
@@ -5061,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() {
@@ -5096,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);
@@ -5189,7 +5201,13 @@ 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);
@@ -5223,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
@@ -5358,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);
       }
     }
@@ -5381,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;
@@ -5571,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() };
@@ -5598,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) {
@@ -5814,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);
@@ -5875,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;
@@ -5933,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 = [];
@@ -5954,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);
   }
@@ -6009,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];
@@ -6085,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++) {
@@ -6186,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() {
@@ -8681,6 +8703,15 @@ function decodeStoredDocument(bytes, discardedFields) {
   }
   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++) {
@@ -8724,6 +8755,9 @@ function wrapEncodedDocumentTable(data) {
         decodedBytes += documentValueBytes(document);
       }
       return document;
+    },
+    readAt(ordinal) {
+      return decoded[ordinal] ?? decodeStoredDocument(blob.subarray(offsets[ordinal], offsets[ordinal + 1]), data.discardedFields);
     }
   };
 }
@@ -8737,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);
@@ -8837,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) {
@@ -9123,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);
@@ -9277,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;
@@ -9341,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;
@@ -9364,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) };
     },
@@ -9382,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) };
     }
   };
@@ -9445,6 +9423,35 @@ function sharedSurfaceTable(payload) {
   if (table.counts.length === 0) return null;
   return { blob: sharedUint8(table.blob), offsets: sharedUint32(table.offsets), counts: sharedUint32(table.counts) };
 }
+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);
@@ -9473,11 +9480,11 @@ function segmentArraysOf(payload, documentData) {
     surfaceTable: surfaceTable === null || surfaceTable.counts.length === 0 ? null : surfaceTable
   };
 }
-function freezeSegmentShared(payload, documents, segmentId) {
+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);
@@ -9544,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)
   };
 }
 
@@ -9580,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();
@@ -9588,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();
@@ -9620,6 +9637,7 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     patternIndexes,
     sizeIndexes,
     fieldNameTable,
+    partialWords,
     trackPositions: source.positionOffsets !== null,
     flatSchemaCache: null,
     lastSchemaRef: null,
@@ -9639,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;
@@ -9654,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) {
@@ -9687,7 +9708,8 @@ function createSharedFrozenSegment(snapshot) {
       }
     },
     wrapEncodedDocumentTable(snapshot.documentTable),
-    snapshot
+    snapshot,
+    snapshot.partialWords
   );
 }
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -10269,10 +10291,10 @@ 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);
+  return freezeEncodedSegmentShared(merged.payload, merged.documents, void 0, analysis);
 }
 function mergeSegmentContents(selections) {
   const docIds = [];
@@ -10301,6 +10323,7 @@ function mergeSegmentContents(selections) {
     totalFieldLengths: lengths.totalFieldLengths,
     docFrequencies: postings.docFrequencies,
     surfaceForms: mergeSurfaceForms2(inputs),
+    partialSpellings: null,
     ...mergeFieldIndexes2(inputs)
   };
   return { payload, documents: mergeDocuments2(inputs, documentCount) };
@@ -10571,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);
@@ -10587,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) {
@@ -10607,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)
   };
 }
@@ -10673,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");
@@ -11150,4 +11179,4 @@ function createDirectExecutor(options) {
   };
 }
 
-export { CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_FILE_BYTES, NATIVE_CRC32_MIN_BYTES, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VALID_HNSW_METRICS, VECTOR_FILE_MAX_VECTORS, VECTOR_FILE_PAYLOAD_VERSION, assembleGraphParts, buildSegmentPayload, bytesToVectors, countDead, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeEveryStoredDocument, decodeMapWithoutFields, decodeStoredDocument, decodeVectorFilePayload, decodeVectorGraphPartPayload, decodeVectorGraphPayload, decodeVectorIndexParts, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, graphPartsOfEarlierPayload, hasStopWords, hasTokenizer, isCompositePartition, isDead, mergeFrozenSegments, mergeSegmentContents, missingWorkerEntry, nodeThreadId, partitionStateOf, readHeapStatistics, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };
+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 };