@delali/narsil 0.3.1-next.75 → 0.3.1-next.76

package/dist/{capabilities-BHNksicw.d.ts → capabilities-1lEYL3WK.d.ts}

@@ -1,6 +1,6 @@
 import { E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { C as ClusterNamespace } from './config-B-GRonqw.js';
-import { h as TaskStore } from './tasks-A8se0J98.js';
+import { C as ClusterNamespace } from './config-DHL2KsfD.js';
+import { h as TaskStore } from './tasks-BTbwBqar.js';
 
 /**
  * Context handed to {@link OnRequestHook} for every inbound request, captured

package/dist/{chunk-7ODNRREZ.mjs → chunk-4344I4MR.mjs}

@@ -1,3 +1,4 @@
+import { tabulatedLevenshtein } from './chunk-GES7U2PM.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
 // src/core/bitset.ts
@@ -72,6 +73,7 @@ var MATCHER_SIMULATION_BYTES_PER_POSITION = 16;
 var MATCHER_STATE_OVERHEAD_BYTES = 96;
 var PATTERN_WORK_FLUSH_UNITS = 65536;
 var PATTERN_RUN_CODE_POINTS = 3;
+var MAX_PATTERN_TOLERANCE = 2;
 var PATTERN_TEST_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "contains"];
 var PATTERN_EXPRESSION_OPERATORS = ["wildcard", "regex"];
 
@@ -1598,6 +1600,160 @@ function shortlist(index, query, tally) {
   return candidates;
 }
 
+// src/core/pattern-index/typo-runs.ts
+var BASIC_PLANE_LAST2 = 65535;
+function isPatternTolerance(value) {
+  if (value === "auto") return true;
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= MAX_PATTERN_TOLERANCE;
+}
+function foldTypoText(text, host) {
+  const folded = [];
+  let longestFold = 0;
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > BASIC_PLANE_LAST2) at++;
+    const before = folded.length;
+    host.appendFoldedCodePoint(codePoint, folded);
+    longestFold = Math.max(longestFold, folded.length - before);
+  }
+  return { folded, longestFold };
+}
+function distinctTypoRuns(text, limit) {
+  const { folded } = text;
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (let at = 0; at + PATTERN_RUN_CODE_POINTS <= folded.length && seen.size < limit; at++) {
+    const key = String.fromCodePoint(folded[at], folded[at + 1], folded[at + 2]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    runs.push(folded[at], folded[at + 1], folded[at + 2]);
+  }
+  return runs;
+}
+function typoRunsNeeded(tolerance, longestFold) {
+  return tolerance * (2 + longestFold) + 1;
+}
+function distinctTypoRunCount(text, limit) {
+  return distinctTypoRuns(text, limit).length / PATTERN_RUN_CODE_POINTS;
+}
+function resolvedTypoTolerance(tolerance, text) {
+  if (tolerance !== "auto") return tolerance;
+  for (let candidate = MAX_PATTERN_TOLERANCE; candidate > 0; candidate--) {
+    const needed = typoRunsNeeded(candidate, text.longestFold);
+    if (distinctTypoRunCount(text, needed) >= needed) return candidate;
+  }
+  return 0;
+}
+
+// src/pattern/typo.ts
+var TypoComparison = class {
+  constructor(text, caseFold, tolerance, host) {
+    this.caseFold = caseFold;
+    this.tolerance = tolerance;
+    this.host = host;
+    const codePoints = [];
+    appendTextCodePoints(text, caseFold, host, codePoints);
+    this.text = caseFold ? String.fromCodePoint(...codePoints) : text;
+    this.shortest = codePoints.length - tolerance;
+    this.longest = codePoints.length + tolerance;
+  }
+  text;
+  shortest;
+  longest;
+  folded = [];
+  within(value, tally) {
+    const compared = this.comparedForm(value);
+    if (compared === null) return false;
+    const { withinTolerance, cells } = tabulatedLevenshtein(this.text, compared, this.tolerance);
+    tally.add(cells);
+    return withinTolerance;
+  }
+  comparedForm(value) {
+    const folded = this.folded;
+    folded.length = 0;
+    let counted = 0;
+    for (let at = 0; at < value.length && counted <= this.longest; at++) {
+      const codePoint = value.codePointAt(at) ?? 0;
+      if (codePoint > BASIC_PLANE_LAST) at++;
+      if (this.caseFold) {
+        this.host.appendFoldedCodePoint(codePoint, folded);
+        counted = folded.length;
+      } else {
+        counted++;
+      }
+    }
+    if (counted > this.longest || counted < this.shortest) return null;
+    return this.caseFold ? String.fromCodePoint(...folded) : value;
+  }
+};
+var typoTestsBySearch = /* @__PURE__ */ new WeakMap();
+function spreadSample(runs, picks) {
+  const count = runs.length / PATTERN_RUN_CODE_POINTS;
+  if (count <= picks) return Uint32Array.from(runs);
+  const sample = new Uint32Array(picks * PATTERN_RUN_CODE_POINTS);
+  for (let pick = 0; pick < picks; pick++) {
+    const run = Math.round(pick * (count - 1) / (picks - 1));
+    for (let offset = 0; offset < PATTERN_RUN_CODE_POINTS; offset++) {
+      sample[pick * PATTERN_RUN_CODE_POINTS + offset] = runs[run * PATTERN_RUN_CODE_POINTS + offset];
+    }
+  }
+  return sample;
+}
+function preparedTypoTest(request) {
+  const text = foldTypoText(request.text, request.host);
+  const tolerance = resolvedTypoTolerance(request.tolerance, text);
+  if (tolerance === 0) return null;
+  const needed = typoRunsNeeded(tolerance, text.longestFold);
+  return {
+    needed,
+    runs: spreadSample(distinctTypoRuns(text, Number.POSITIVE_INFINITY), Math.max(needed, SHORTLIST_RUN_LOOKUPS)),
+    comparison: new TypoComparison(request.text, request.caseFold, tolerance, request.host)
+  };
+}
+function typoTestFor(request) {
+  let tests = typoTestsBySearch.get(request.meter);
+  if (tests === void 0) {
+    tests = /* @__PURE__ */ new Map();
+    typoTestsBySearch.set(request.meter, tests);
+  }
+  const key = `${request.caseFold}|${request.tolerance}|${request.text}`;
+  const known = tests.get(key);
+  if (known !== void 0) return known;
+  const test = preparedTypoTest(request);
+  tests.set(key, test);
+  return test;
+}
+function rarestLists(index, test, tally) {
+  const { runs, needed } = test;
+  if (runs.length < needed * PATTERN_RUN_CODE_POINTS) return [index.documents()];
+  const lists = [];
+  for (let at = 0; at < runs.length; at += PATTERN_RUN_CODE_POINTS) {
+    tally.add(1);
+    lists.push(index.postings(runs[at], runs[at + 1], runs[at + 2]));
+  }
+  lists.sort((left, right) => left.length - right.length);
+  return lists.slice(0, needed);
+}
+function matchWithinTolerance(request, test, tally) {
+  const { index, matches } = request;
+  const checked = new Uint32Array(matches.length);
+  let matched = false;
+  const testValue = (value) => {
+    if (!matched) matched = test.comparison.within(value, tally);
+  };
+  for (const list of rarestLists(index, test, tally)) {
+    tally.add(list.length);
+    for (const ordinal of list) {
+      if (ordinal >>> 5 >= matches.length || bitsetHas(checked, ordinal)) continue;
+      bitsetSet(checked, ordinal);
+      if (bitsetHas(matches, ordinal)) continue;
+      matched = false;
+      forEachTextValue(request.valueOf(ordinal), testValue);
+      if (matched) bitsetSet(matches, ordinal);
+    }
+  }
+}
+
 // src/pattern/work-tally.ts
 var WorkTally = class {
   constructor(meter) {
@@ -1675,9 +1831,20 @@ function matchesText(matcher, text, caseFold, host, folded, tally) {
   }
   return matcher.matched();
 }
+function answeredByTypoTest(request, tally) {
+  if (request.operator !== "eq" || request.tolerance === 0) return false;
+  const test = typoTestFor(request);
+  if (test === null) return false;
+  matchWithinTolerance(request, test, tally);
+  return true;
+}
 function matchPattern(request) {
   const { operator, caseFold, index, matches, host } = request;
   const tally = new WorkTally(request.meter);
+  if (answeredByTypoTest(request, tally)) {
+    tally.flush();
+    return;
+  }
   const test = operator === "wildcard" || operator === "regex" ? expressionTest(request, operator) : literalTest(request);
   const shortlisted = shortlist(index, test.runs, tally);
   const scanning = shortlisted === null;
@@ -2047,4 +2214,4 @@ var patternSearchModule = {
   expressionFootprint
 };
 
-export { DEFAULT_PATTERN_WORK_CAP, GrowableUint32, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_BUDGET_BYTES, MATCHER_STATE_OVERHEAD_BYTES, MAX_PATTERN_POSITIONS, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_EXPRESSION_OPERATORS, PATTERN_RUN_CODE_POINTS, PATTERN_TEST_OPERATORS, PATTERN_WORK_FLUSH_UNITS, bitsetAnd, bitsetAndInto, bitsetAndNotInto, bitsetFromSet, bitsetHas, bitsetIsEmpty, bitsetNot, bitsetOrInto, bitsetSet, createBitSet, patternSearchModule };
+export { DEFAULT_PATTERN_WORK_CAP, GrowableUint32, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_BUDGET_BYTES, MATCHER_STATE_OVERHEAD_BYTES, MAX_PATTERN_POSITIONS, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_EXPRESSION_OPERATORS, PATTERN_RUN_CODE_POINTS, PATTERN_TEST_OPERATORS, PATTERN_WORK_FLUSH_UNITS, bitsetAnd, bitsetAndInto, bitsetAndNotInto, bitsetFromSet, bitsetHas, bitsetIsEmpty, bitsetNot, bitsetOrInto, bitsetSet, createBitSet, distinctTypoRunCount, foldTypoText, isPatternTolerance, patternSearchModule, typoRunsNeeded };

package/dist/{chunk-NAMGDK45.mjs → chunk-D4EF7J3I.mjs}

@@ -1,7 +1,8 @@
 import { MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, MAX_FILTER_DEPTH, DEFAULT_PAGE_SIZE, MAX_FILTER_ARRAY_SIZE, GEO_UNIT_METRES, MAX_FILTER_TESTS, PREFIX_MAX_EXPANSIONS, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY } from './chunk-V3B24XR7.mjs';
-import { DEFAULT_PATTERN_WORK_CAP, patternSearchModule, PATTERN_TEST_OPERATORS, bitsetIsEmpty, PATTERN_EXPRESSION_OPERATORS, MAX_PATTERN_POSITIONS, createBitSet, bitsetSet, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-7ODNRREZ.mjs';
-import { getFlatSchema, tokenize, getFieldValueByInternalId, getFieldValueForDoc, fuzzyTermMatches } from './chunk-UOJIV2NG.mjs';
+import { DEFAULT_PATTERN_WORK_CAP, patternSearchModule, PATTERN_TEST_OPERATORS, bitsetIsEmpty, PATTERN_EXPRESSION_OPERATORS, MAX_PATTERN_POSITIONS, isPatternTolerance, foldTypoText, typoRunsNeeded, distinctTypoRunCount, createBitSet, bitsetSet, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-4344I4MR.mjs';
+import { getFlatSchema, tokenize, getFieldValueByInternalId, getFieldValueForDoc } from './chunk-NO3ABFLE.mjs';
 import { schemaFieldsOf, MAX_LATITUDE_DEGREES, MAX_LONGITUDE_DEGREES, MIN_POLYGON_POINTS, flattenSchema, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, EARTH_RADIUS_METERS, RADIUS_BOX_MARGIN_RATIO, RADIUS_BOX_MARGIN_RADIANS, FULL_TURN_DEGREES, ANTIMERIDIAN_SPAN_DEGREES, PROTOTYPE_POLLUTION_KEYS, DEG_TO_RAD, LOCATION_CODE_BITS_PER_AXIS, isLatitude, isLongitude, isWordIndexedFieldType, partialFieldsOf, MAX_COVERING_CELLS } from './chunk-356UOTK2.mjs';
+import { fuzzyTermMatches } from './chunk-GES7U2PM.mjs';
 import { appendFoldedCodePoint, compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, singleFoldTable, holdsUnpairedSurrogate, isSortMode, SORT_MODES, compareSortValues, foldedCodePointCount, codePointCount } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
@@ -1074,6 +1075,7 @@ function requirePatternOperands(fieldPath, filter, type) {
     requirePatternField(fieldPath, "caseFold", type);
   }
   requireExpressions(fieldPath, filter, type);
+  if (filter.tolerance !== void 0) requirePatternField(fieldPath, "tolerance", type);
   if (parsedTypeOf(type)?.pattern !== true) return;
   const caseFold = filter.caseFold === true;
   for (const operator of PATTERN_TEST_OPERATORS) {
@@ -1091,6 +1093,31 @@ function requirePatternOperands(fieldPath, filter, type) {
       if (typeof text === "string") requirePatternText(fieldPath, operator, text, false);
     }
   }
+  requireTolerance(fieldPath, filter);
+}
+function requireTolerance(fieldPath, filter) {
+  const { tolerance, eq } = filter;
+  if (tolerance === void 0) return;
+  if (!isPatternTolerance(tolerance)) {
+    invalid(`"tolerance" on field "${fieldPath}" must be 0, 1, 2, or "auto"`, fieldPath, "tolerance");
+  }
+  if (typeof eq !== "string") {
+    invalid(
+      `"tolerance" applies only to an "eq" test, while the filter on field "${fieldPath}" sets no "eq" with text`,
+      fieldPath,
+      "tolerance"
+    );
+  }
+  if (tolerance === 0 || tolerance === "auto") return;
+  const text = foldTypoText(eq, PATTERN_HOST);
+  const requiredRuns = typoRunsNeeded(tolerance, text.longestFold);
+  const distinctRuns = distinctTypoRunCount(text, requiredRuns);
+  if (distinctRuns >= requiredRuns) return;
+  throw new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `A tolerance of ${tolerance} on "eq" of pattern field "${fieldPath}" needs ${requiredRuns} distinct runs of three code points in the case fold of the text, while the text holds ${distinctRuns}. Lengthen the text, lower the tolerance, or set it to "auto"`,
+    { fieldPath, operator: "tolerance", requiredRuns, distinctRuns }
+  );
 }
 function requireWellFormedText(fieldPath, filter) {
   for (const [operator, operand] of Object.entries(filter)) {
@@ -1112,6 +1139,7 @@ var TEXT_OPERATORS = ["startsWith", "endsWith"];
 var EQUALITY_OPERATORS = ["eq", "ne"];
 var LIST_OPERATORS = ["in", "nin"];
 var GEO_OPERATORS = ["radius", "polygon"];
+var TEST_MODIFIERS = /* @__PURE__ */ new Set(["caseFold", "tolerance"]);
 function invalidShape(message) {
   throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message);
 }
@@ -1215,7 +1243,7 @@ function filterTestCount(expression) {
 function testsIn(filter) {
   let tests = 0;
   for (const [operator, operand] of Object.entries(filter)) {
-    if (operator === "caseFold") continue;
+    if (TEST_MODIFIERS.has(operator)) continue;
     tests += operator === "size" && isObjectRecord(operand) ? Math.max(1, Object.keys(operand).length) : 1;
   }
   return Math.max(1, tests);

package/dist/{chunk-YOVS4EV5.mjs → chunk-DFFQOA7S.mjs}

@@ -1,13 +1,14 @@
-import { requirePatternSearchFor, patternIndexOf, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, projectionKeepsField, setNestedValue, fnv1a, requirePatternSearch, PATTERN_HOST, everyValueFacetConfig, mergeFacets, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges } from './chunk-NAMGDK45.mjs';
+import { requirePatternSearchFor, patternIndexOf, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, projectionKeepsField, setNestedValue, fnv1a, requirePatternSearch, PATTERN_HOST, everyValueFacetConfig, mergeFacets, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges } from './chunk-D4EF7J3I.mjs';
 import { getLanguage, detectRuntime } from './chunk-4MQ5F4IL.mjs';
 import { MAX_DOC_ID_LENGTH, GEO_UNIT_METRES } from './chunk-V3B24XR7.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-AMGDG4ZJ.mjs';
 import { noteFallback } from './chunk-2E35UM3G.mjs';
-import { GrowableUint32, bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-7ODNRREZ.mjs';
-import { encodePartialSpellings, countSpelling, expandTermPrefix, suggestDisplayTerms, spellingCountsOf, codePointOrder, encodeStringBlob, partialWordSearchModule, partitionDocumentFrequency } from './chunk-AIUOAN7Y.mjs';
-import { tokenizeOptions, getNestedValue, visitTokens, textFieldsChanged, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId } from './chunk-UOJIV2NG.mjs';
+import { GrowableUint32, bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, isPatternTolerance, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-4344I4MR.mjs';
+import { encodePartialSpellings, countSpelling, expandTermPrefix, suggestDisplayTerms, spellingCountsOf, codePointOrder, encodeStringBlob, partialWordSearchModule, partitionDocumentFrequency } from './chunk-PJU6EF22.mjs';
+import { tokenizeOptions, getNestedValue, visitTokens, textFieldsChanged, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId } from './chunk-NO3ABFLE.mjs';
 import { partialFieldsOf, schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-356UOTK2.mjs';
 import { MAX_M, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-KEHK2O6P.mjs';
+import { fuzzyPrefixOf, boundedLevenshtein } from './chunk-GES7U2PM.mjs';
 import { compareCodePoints, toReducedSortValue, readSortField, defaultSortMode, compareComparableValues, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { totalmem } from 'os';
@@ -1974,12 +1975,13 @@ function textsOf(operand) {
 }
 function evaluatePatternTests(fieldPath, filter, context, bitsets) {
   const caseFold = filter.caseFold === true;
-  const matching = (operator, texts) => {
+  const matching = (operator, texts, tolerance = 0) => {
     const into = createBitSet(context.capacity);
-    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, into);
+    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, tolerance, into);
     return into;
   };
-  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq]));
+  const eqTolerance = isPatternTolerance(filter.tolerance) ? filter.tolerance : 0;
+  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq], eqTolerance));
   if (typeof filter.ne === "string") bitsets.push(excluding(context, fieldPath, matching("eq", [filter.ne])));
   if (filter.in !== void 0) bitsets.push(matching("eq", textsOf(filter.in)));
   if (filter.nin !== void 0) bitsets.push(excluding(context, fieldPath, matching("eq", textsOf(filter.nin))));
@@ -2035,7 +2037,7 @@ function elementBits(context, fieldPath, parsed, value) {
   const { capacity } = context;
   if (parsed.pattern) {
     const matches = createBitSet(capacity);
-    context.matchPattern(fieldPath, "eq", value, false, matches);
+    context.matchPattern(fieldPath, "eq", value, false, 0, matches);
     return matches;
   }
   if (typeof value === "number")
@@ -2048,7 +2050,7 @@ function anyElementBits(context, fieldPath, parsed, values) {
   const { capacity } = context;
   const union = createBitSet(capacity);
   if (parsed.pattern) {
-    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, union);
+    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, 0, union);
     return union;
   }
   if (parsed.base === "enum[]") {
@@ -2195,6 +2197,7 @@ var FIELD_FILTER_OPERATORS = [
   "wildcard",
   "regex",
   "caseFold",
+  "tolerance",
   "containsAll",
   "matchesAny",
   "size",
@@ -2928,13 +2931,14 @@ function buildFilterContext(state, schema, meter) {
     sizeIndex: (fieldPath) => state.sizeIndexes.get(fieldPath),
     textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
     isPatternField: (fieldPath) => patternFields.has(fieldPath),
-    matchPattern: (fieldPath, operator, text, caseFold, into) => {
+    matchPattern: (fieldPath, operator, text, caseFold, tolerance, into) => {
       const index = state.patternIndexes.get(fieldPath);
       if (index === void 0) return;
       requirePatternSearch(fieldPath).matchInto({
         operator,
         text,
         caseFold,
+        tolerance,
         index,
         matches: into,
         meter,

package/dist/{chunk-WL2GDSCV.mjs → chunk-G7IP3UDZ.mjs}

@@ -1,8 +1,9 @@
-import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex } from './chunk-NAMGDK45.mjs';
+import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex } from './chunk-D4EF7J3I.mjs';
 import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, DEFAULT_LIMIT, DEFAULT_MAX_PER_GROUP, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_OFFSET, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-V3B24XR7.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
-import { tokenize, fuzzyTermMatches } from './chunk-UOJIV2NG.mjs';
+import { tokenize } from './chunk-NO3ABFLE.mjs';
 import { partialFieldsOf, MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, flattenSchema, isWordIndexedFieldType, isGeopointOrVectorType } from './chunk-356UOTK2.mjs';
+import { fuzzyTermMatches } from './chunk-GES7U2PM.mjs';
 import { holdsUnpairedSurrogate, compareCodePoints, compareComparableKeys, codePointCount } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 

package/dist/chunk-GES7U2PM.mjs

@@ -0,0 +1,68 @@
+// src/core/fuzzy.ts
+var FIRST_SURROGATE = 55296;
+var LAST_SURROGATE = 57343;
+var LAST_BASIC_PLANE_CODE_POINT = 65535;
+function hasSurrogate(text) {
+  for (let index = 0; index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit >= FIRST_SURROGATE && unit <= LAST_SURROGATE) return true;
+  }
+  return false;
+}
+function fuzzyPrefixOf(queryTerm, prefixLength) {
+  let end = 0;
+  for (let counted = 0; counted < prefixLength && end < queryTerm.length; counted++) {
+    const codePoint = queryTerm.codePointAt(end);
+    end += codePoint !== void 0 && codePoint > LAST_BASIC_PLANE_CODE_POINT ? 2 : 1;
+  }
+  return queryTerm.slice(0, end);
+}
+function fuzzyTermMatches(queryTerm, indexTerm, tolerance, prefixLength) {
+  if (queryTerm === indexTerm) return true;
+  if (tolerance <= 0) return false;
+  if (!indexTerm.startsWith(fuzzyPrefixOf(queryTerm, prefixLength))) return false;
+  return boundedLevenshtein(queryTerm, indexTerm, tolerance).withinTolerance;
+}
+function boundedLevenshtein(a, b, tolerance) {
+  if (tolerance < 0) return { distance: -1, withinTolerance: false, cells: 0 };
+  if (a === b) return { distance: 0, withinTolerance: true, cells: 0 };
+  return tabulatedLevenshtein(a, b, tolerance);
+}
+function tabulatedLevenshtein(a, b, tolerance) {
+  if (tolerance < 0) return { distance: -1, withinTolerance: false, cells: 0 };
+  if (hasSurrogate(a) || hasSurrogate(b)) return bandedDistance(Array.from(a), Array.from(b), tolerance);
+  return bandedDistance(a, b, tolerance);
+}
+function bandedDistance(a, b, tolerance) {
+  const m = a.length;
+  const n = b.length;
+  const beyond = tolerance + 1;
+  if (Math.abs(m - n) > tolerance) return { distance: beyond, withinTolerance: false, cells: 0 };
+  let previous = new Uint32Array(n + 1).fill(beyond);
+  let current = new Uint32Array(n + 1).fill(beyond);
+  const firstRowEnd = Math.min(n, tolerance);
+  for (let j = 0; j <= firstRowEnd; j++) previous[j] = j;
+  let cells = 0;
+  for (let i = 1; i <= m; i++) {
+    const low = Math.max(1, i - tolerance);
+    const high = Math.min(n, i + tolerance);
+    current[low - 1] = low === 1 ? i : beyond;
+    let rowMin = current[low - 1];
+    const character = a[i - 1];
+    if (high >= low) cells += high - low + 1;
+    for (let j = low; j <= high; j++) {
+      const substitution = previous[j - 1] + (character === b[j - 1] ? 0 : 1);
+      const cell = Math.min(previous[j] + 1, current[j - 1] + 1, substitution, beyond);
+      current[j] = cell;
+      if (cell < rowMin) rowMin = cell;
+    }
+    if (rowMin > tolerance) return { distance: beyond, withinTolerance: false, cells };
+    const finished = previous;
+    previous = current;
+    current = finished;
+  }
+  const distance = previous[n];
+  return { distance, withinTolerance: distance <= tolerance, cells };
+}
+
+export { boundedLevenshtein, fuzzyPrefixOf, fuzzyTermMatches, tabulatedLevenshtein };

package/dist/{chunk-LOARLB4F.mjs → chunk-HH6ALOUZ.mjs}

@@ -1,14 +1,14 @@
-import { validateWorkerConfig, validateIndexName, validatePatternValueLimit, requireSurfaceFormsForPartialFields, validateBM25Params, validatePartitionConfig, executeQuery, queryBindingOf, executePreflight, executeSuggest, executeListDocuments, validateDocId } from './chunk-WL2GDSCV.mjs';
+import { validateWorkerConfig, validateIndexName, validatePatternValueLimit, requireSurfaceFormsForPartialFields, validateBM25Params, validatePartitionConfig, executeQuery, queryBindingOf, executePreflight, executeSuggest, executeListDocuments, validateDocId } from './chunk-G7IP3UDZ.mjs';
 import { ReplicationMessageTypes } from './chunk-GCM3JFVA.mjs';
 import { WIRE_BATCH_BUDGET, resolveVectorText, bindEngineCore, restoredConfigFields, restoredEmbedding, collectRequiredFieldFailures, embedChunkDocuments, providedDocId, requireDocumentObject, admitInsert, asBatchInsertError, requireMatchingDocId, embedDocumentFields, assertDocumentCarriesMappedVectors, admitBufferedUpsert, createPendingAdmissions, recordPendingAdmission } from './chunk-BT62MUM5.mjs';
-import { NATIVE_CRC32_MIN_BYTES, generateId, decodeEveryStoredDocument, createSharedFrozenSegment, shareSegmentArrays, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, requirePartialWordSearchFor, MAX_FILE_BYTES, resolveWorkerEntry, missingWorkerEntry, readHeapStatistics, nodeThreadId, CHECKSUM_YIELD_CHUNK_BYTES, createPartitionManager, buildSegmentPayload, resolvePartitionInsertOptions, createFrozenSegment, resolveRequestThreadCount, vectorsPerFile, vectorsToBytes, VECTOR_FILE_PAYLOAD_VERSION, deadBitsWhere, NO_LIVE_VECTOR_AT_POSITION, createPartitionIndex, selectionKeeps, decodeMapWithoutFields, isCompositePartition, segmentArraysOf, mergeSegmentContents, survivorDocumentsOf, partitionStateOf, VECTOR_FILE_MAX_VECTORS, deadBytesFor, resolveIndexAnalysis, mergeFrozenSegments, workerResourceLimits, decodeVectorIndexParts, bytesToVectors, freezeSegmentShared, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, SHUTDOWN_TIMEOUT_MS, decodeVectorFilePayload, decodeVectorGraphPartPayload, assembleGraphParts, countDead, encodeSegmentState, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, VALID_HNSW_METRICS, spawnNodeWorker, decodeVectorGraphPayload, graphPartsOfEarlierPayload, decodeStoredDocument, isDead } from './chunk-YOVS4EV5.mjs';
-import { requirePatternSearchFor, collectQueryTermStats, mergePartitionStats, oversampledFacetConfig, fnv1a, availablePatternSearch, kWayMerge, mergeFacets, PATTERN_HOST, setNestedValue } from './chunk-NAMGDK45.mjs';
+import { NATIVE_CRC32_MIN_BYTES, generateId, decodeEveryStoredDocument, createSharedFrozenSegment, shareSegmentArrays, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, requirePartialWordSearchFor, MAX_FILE_BYTES, resolveWorkerEntry, missingWorkerEntry, readHeapStatistics, nodeThreadId, CHECKSUM_YIELD_CHUNK_BYTES, createPartitionManager, buildSegmentPayload, resolvePartitionInsertOptions, createFrozenSegment, resolveRequestThreadCount, vectorsPerFile, vectorsToBytes, VECTOR_FILE_PAYLOAD_VERSION, deadBitsWhere, NO_LIVE_VECTOR_AT_POSITION, createPartitionIndex, selectionKeeps, decodeMapWithoutFields, isCompositePartition, segmentArraysOf, mergeSegmentContents, survivorDocumentsOf, partitionStateOf, VECTOR_FILE_MAX_VECTORS, deadBytesFor, resolveIndexAnalysis, mergeFrozenSegments, workerResourceLimits, decodeVectorIndexParts, bytesToVectors, freezeSegmentShared, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, SHUTDOWN_TIMEOUT_MS, decodeVectorFilePayload, decodeVectorGraphPartPayload, assembleGraphParts, countDead, encodeSegmentState, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, VALID_HNSW_METRICS, spawnNodeWorker, decodeVectorGraphPayload, graphPartsOfEarlierPayload, decodeStoredDocument, isDead } from './chunk-DFFQOA7S.mjs';
+import { requirePatternSearchFor, collectQueryTermStats, mergePartitionStats, oversampledFacetConfig, fnv1a, availablePatternSearch, kWayMerge, mergeFacets, PATTERN_HOST, setNestedValue } from './chunk-D4EF7J3I.mjs';
 import { detectRuntime, getLanguage } from './chunk-4MQ5F4IL.mjs';
 import { MAX_INDEX_CONFIGURATION_BYTES, STATISTICS_BROADCAST_INTERVAL_MS, MAX_SWEEP_INTERVAL_MS, MIN_SWEEP_INTERVAL_MS, HEAP_PRESSURE_WARNING_FRACTION, MAX_EXPORT_LINE_BYTES, IMPORT_BATCH_DOCUMENTS, FOREIGN_STATS_TTL_MS, MAX_IMPORT_REFUSALS_REPORTED, BATCH_CHUNK_SIZE, MIN_DOCUMENTS_FOR_SEGMENTS, HEAP_PRESSURE_REARM_FRACTION, EXPORT_CHUNK_BYTES } from './chunk-V3B24XR7.mjs';
 import { releaseLocksHeldBy } from './chunk-AMGDG4ZJ.mjs';
 import { requireSearchBackendSettings } from './chunk-2E35UM3G.mjs';
-import { DEFAULT_PATTERN_WORK_CAP, MATCHER_STATE_BUDGET_BYTES, PATTERN_TEST_OPERATORS, PATTERN_EXPRESSION_OPERATORS, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES } from './chunk-7ODNRREZ.mjs';
-import { getNestedValue, parseVectorDimension } from './chunk-UOJIV2NG.mjs';
+import { DEFAULT_PATTERN_WORK_CAP, MATCHER_STATE_BUDGET_BYTES, PATTERN_TEST_OPERATORS, PATTERN_EXPRESSION_OPERATORS, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES } from './chunk-4344I4MR.mjs';
+import { getNestedValue, parseVectorDimension } from './chunk-NO3ABFLE.mjs';
 import { extractVectorFieldsFromSchema, messagePackUpperBoundBytes, validateSchema, requireCreatableSchema, validateVectorPromotion, validateVectorStorage, raiseEarlierReleaseGraphSetting, flattenSchema, isSingleStringFieldType, requireValidFieldTypes, encodeDocument, VECTOR_PATTERN, schemaFieldsOf, MAX_DOCUMENT_NESTING_DEPTH, isQuantizationMode, isStorageMode, validateRequiredFields, requireDocumentWithinSizeLimit, validateDocument, validateDocumentStrict } from './chunk-356UOTK2.mjs';
 import { MIN_M } from './chunk-KEHK2O6P.mjs';
 import { compareCodePoints, foldedCodePointCount, codePointCount } from './chunk-IBR6634K.mjs';

package/dist/{chunk-UOJIV2NG.mjs → chunk-NO3ABFLE.mjs}

@@ -457,67 +457,6 @@ function* tokenizeIterator(text, language, options) {
   }
 }
 
-// src/core/fuzzy.ts
-var FIRST_SURROGATE = 55296;
-var LAST_SURROGATE = 57343;
-var LAST_BASIC_PLANE_CODE_POINT = 65535;
-function hasSurrogate(text) {
-  for (let index = 0; index < text.length; index++) {
-    const unit = text.charCodeAt(index);
-    if (unit >= FIRST_SURROGATE && unit <= LAST_SURROGATE) return true;
-  }
-  return false;
-}
-function fuzzyPrefixOf(queryTerm, prefixLength) {
-  let end = 0;
-  for (let counted = 0; counted < prefixLength && end < queryTerm.length; counted++) {
-    const codePoint = queryTerm.codePointAt(end);
-    end += codePoint !== void 0 && codePoint > LAST_BASIC_PLANE_CODE_POINT ? 2 : 1;
-  }
-  return queryTerm.slice(0, end);
-}
-function fuzzyTermMatches(queryTerm, indexTerm, tolerance, prefixLength) {
-  if (queryTerm === indexTerm) return true;
-  if (tolerance <= 0) return false;
-  if (!indexTerm.startsWith(fuzzyPrefixOf(queryTerm, prefixLength))) return false;
-  return boundedLevenshtein(queryTerm, indexTerm, tolerance).withinTolerance;
-}
-function boundedLevenshtein(a, b, tolerance) {
-  if (tolerance < 0) return { distance: -1, withinTolerance: false };
-  if (a === b) return { distance: 0, withinTolerance: true };
-  if (hasSurrogate(a) || hasSurrogate(b)) return bandedDistance(Array.from(a), Array.from(b), tolerance);
-  return bandedDistance(a, b, tolerance);
-}
-function bandedDistance(a, b, tolerance) {
-  const m = a.length;
-  const n = b.length;
-  const beyond = tolerance + 1;
-  if (Math.abs(m - n) > tolerance) return { distance: beyond, withinTolerance: false };
-  let previous = new Uint32Array(n + 1).fill(beyond);
-  let current = new Uint32Array(n + 1).fill(beyond);
-  const firstRowEnd = Math.min(n, tolerance);
-  for (let j = 0; j <= firstRowEnd; j++) previous[j] = j;
-  for (let i = 1; i <= m; i++) {
-    const low = Math.max(1, i - tolerance);
-    const high = Math.min(n, i + tolerance);
-    current[low - 1] = low === 1 ? i : beyond;
-    let rowMin = current[low - 1];
-    const character = a[i - 1];
-    for (let j = low; j <= high; j++) {
-      const substitution = previous[j - 1] + (character === b[j - 1] ? 0 : 1);
-      const cell = Math.min(previous[j] + 1, current[j - 1] + 1, substitution, beyond);
-      current[j] = cell;
-      if (cell < rowMin) rowMin = cell;
-    }
-    if (rowMin > tolerance) return { distance: beyond, withinTolerance: false };
-    const finished = previous;
-    previous = current;
-    current = finished;
-  }
-  const distance = previous[n];
-  return { distance, withinTolerance: distance <= tolerance };
-}
-
 // src/core/partition/utils.ts
 function getOrCreateFieldNameIndex(table, fieldName) {
   const existing = table.indexMap.get(fieldName);
@@ -590,4 +529,4 @@ function getFieldValueByInternalId(docStore, internalId, fieldPath) {
   return getFieldValueForDoc(docStore, externalId, fieldPath);
 }
 
-export { boundedLevenshtein, clearNormalizationCache, configureNormalizationCache, fuzzyPrefixOf, fuzzyTermMatches, getFieldValueByInternalId, getFieldValueForDoc, getFlatSchema, getNestedValue, getNormalizationCacheSize, getOrCreateFieldNameIndex, parseVectorDimension, resetNormalizationCache, textFieldsChanged, tokenize, tokenizeIterator, tokenizeOptions, visitTokens };
+export { clearNormalizationCache, configureNormalizationCache, getFieldValueByInternalId, getFieldValueForDoc, getFlatSchema, getNestedValue, getNormalizationCacheSize, getOrCreateFieldNameIndex, parseVectorDimension, resetNormalizationCache, textFieldsChanged, tokenize, tokenizeIterator, tokenizeOptions, visitTokens };

package/dist/{chunk-AIUOAN7Y.mjs → chunk-PJU6EF22.mjs}

@@ -1,4 +1,5 @@
-import { tokenizeOptions, getNestedValue, tokenizeIterator, fuzzyTermMatches } from './chunk-UOJIV2NG.mjs';
+import { tokenizeOptions, getNestedValue, tokenizeIterator } from './chunk-NO3ABFLE.mjs';
+import { fuzzyTermMatches } from './chunk-GES7U2PM.mjs';
 import { compareCodePoints } from './chunk-IBR6634K.mjs';
 
 // src/core/partition/suggestions.ts

package/dist/{client-D4sXFS9f.d.ts → client-ZXcbSViH.d.ts}

@@ -1,6 +1,6 @@
 import { P as PartitionConfig, A as AnyDocument, a as InsertOptions, W as WriteOptions } from './schema-DgyDijhf.js';
-import { V as VectorMaintenanceResult, B as BatchResult, L as ListParams, h as ListResult, I as IndexInfo, g as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, j as PreflightResult, k as SuggestParams, l as SuggestResult } from './memory-M9kPmYP8.js';
-import { e as TaskRecord, M as MemoryStatsResponse, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-A8se0J98.js';
+import { V as VectorMaintenanceResult, B as BatchResult, L as ListParams, h as ListResult, I as IndexInfo, g as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, j as PreflightResult, k as SuggestParams, l as SuggestResult } from './memory-DW3OJ0im.js';
+import { e as TaskRecord, M as MemoryStatsResponse, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-BTbwBqar.js';
 
 /**
  * This is the `fetch` implementation the client sends every request through.

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-M9kPmYP8.js';
-export { A as ASYNC_IMPORT_CAPABILITY, D as DOCUMENT_EXPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-BHNksicw.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-A8se0J98.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-D4sXFS9f.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-DW3OJ0im.js';
+export { A as ASYNC_IMPORT_CAPABILITY, D as DOCUMENT_EXPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-1lEYL3WK.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-BTbwBqar.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-ZXcbSViH.js';
 import './schema-DgyDijhf.js';
 import './adapters-79OIa4xm.js';
-import './config-B-GRonqw.js';
-import './config-C1kbq1X2.js';
+import './config-DHL2KsfD.js';
+import './config-DTe5EbWW.js';
 import './types-ChrVy4lH.js';
 import './types-Cb9kiY5P.js';

package/dist/{config-B-GRonqw.d.ts → config-DHL2KsfD.d.ts}

@@ -1,4 +1,4 @@
-import { N as NarsilConfig } from './config-C1kbq1X2.js';
+import { N as NarsilConfig } from './config-DTe5EbWW.js';
 import { A as AllocationTable, N as NodeRole, a as NodeRegistration, C as ClusterCoordinator, b as NodeCapacity } from './types-ChrVy4lH.js';
 import { N as NodeTransport } from './types-Cb9kiY5P.js';
 

package/dist/{config-C1kbq1X2.d.ts → config-DTe5EbWW.d.ts}

@@ -1,5 +1,5 @@
 import { P as PersistenceAdapter, I as InvalidationAdapter, E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { Q as QueryParams, e as QueryResult, f as NarsilEventHandlers } from './memory-M9kPmYP8.js';
+import { Q as QueryParams, e as QueryResult, f as NarsilEventHandlers } from './memory-DW3OJ0im.js';
 import { I as IndexConfig, A as AnyDocument } from './schema-DgyDijhf.js';
 
 /**
@@ -214,7 +214,9 @@ interface NarsilConfig {
      * each step of its matcher. For a text whose case fold is shorter than three
      * code points, it counts each document that it checks as an entry that it
      * reads. It counts an `in` or `nin` test as one `eq` test for each distinct
-     * value in its list. Once the count passes the cap, the engine throws
+     * value in its list. For an `eq` test with a `tolerance`, it also adds one
+     * unit for each cell that it fills in the table of edit distances between
+     * the text and a value. Once the count passes the cap, the engine throws
      * `SEARCH_WORK_CAP_EXCEEDED`. The cap
      * defaults to 25,000,000 units. For any value other than a whole number from
      * 1 to `Number.MAX_SAFE_INTEGER`, {@link createNarsil} throws

package/dist/{direct-executor-AVNWB73C.mjs → direct-executor-Q7PNCGZB.mjs}

@@ -1,16 +1,17 @@
-export { createDirectExecutor } from './chunk-YOVS4EV5.mjs';
-import './chunk-NAMGDK45.mjs';
+export { createDirectExecutor } from './chunk-DFFQOA7S.mjs';
+import './chunk-D4EF7J3I.mjs';
 import './chunk-4MQ5F4IL.mjs';
 import './chunk-V3B24XR7.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-AMGDG4ZJ.mjs';
 import './chunk-ZJ4CSAB2.mjs';
 import './chunk-2E35UM3G.mjs';
-import './chunk-7ODNRREZ.mjs';
-import './chunk-AIUOAN7Y.mjs';
-import './chunk-UOJIV2NG.mjs';
+import './chunk-4344I4MR.mjs';
+import './chunk-PJU6EF22.mjs';
+import './chunk-NO3ABFLE.mjs';
 import './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-U2BKYEC7.mjs';
 import './chunk-IBR6634K.mjs';
 import './chunk-I64LXKO3.mjs';

package/dist/distribution.d.ts

@@ -1,12 +1,12 @@
-import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-B-GRonqw.js';
-export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-B-GRonqw.js';
-import { B as BatchResult, L as ListParams, h as ListResult, k as SuggestParams, l as SuggestResult, Q as QueryParams, j as PreflightResult, g as IndexStats, P as PartitionStatsResult, M as MemoryStats, m as NarsilEventMap, e as QueryResult } from './memory-M9kPmYP8.js';
+import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-DHL2KsfD.js';
+export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-DHL2KsfD.js';
+import { B as BatchResult, L as ListParams, h as ListResult, k as SuggestParams, l as SuggestResult, Q as QueryParams, j as PreflightResult, g as IndexStats, P as PartitionStatsResult, M as MemoryStats, m as NarsilEventMap, e as QueryResult } from './memory-DW3OJ0im.js';
 import { I as IndexConfig, A as AnyDocument, a as InsertOptions } from './schema-DgyDijhf.js';
 import { b as NodeCapacity, N as NodeRole } from './types-ChrVy4lH.js';
 export { c as AllocationConstraints, d as AllocationEvent, A as AllocationTable, C as ClusterCoordinator, e as NodeEvent, a as NodeRegistration, P as PartitionAssignment, f as PartitionState, S as SchemaEvent, U as UnassignedReason } from './types-ChrVy4lH.js';
-import { N as Narsil } from './engine-DcGSd5vh.js';
+import { N as Narsil } from './engine-BjPBzWkA.js';
 export { L as ListenHandler, N as NodeTransport, R as RespondFn, T as TransportConfig, a as TransportMessage } from './types-Cb9kiY5P.js';
-import './config-C1kbq1X2.js';
+import './config-DTe5EbWW.js';
 import './adapters-79OIa4xm.js';
 
 /**

package/dist/distribution.mjs

@@ -1,22 +1,23 @@
 import { MAX_MESSAGE_SIZE_BYTES } from './chunk-UNEEFTEU.mjs';
 import { validateIndexName, indexConfigKey, withPartitionCount, indexSettingsOf, putIndexMetadata, getIndexMetadata, getClusterIndexConfig } from './chunk-PXDY5VRT.mjs';
-import { requireKnownConfig, resolveRunnableConfig, createEngineCore, startEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, buildArchiveFromMemory, indexMetadataOf, encodeIndexConfiguration, archiveStream, applyIndexEntry, applyDeleteEntry, requireConfigurationWithinSizeLimit, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, memoryCheckpointStore, readSnapshotArchive, createByteReader, openChecksummedEnvelope, loadPartitionSegments, readListedFile, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, crc32Init, crc32Final, crc32Update, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-LOARLB4F.mjs';
-import { now, listBindingOf, requireSurfaceFormsForPartialFields, queryBindingOf, hitsKeptPerGroup, clampLimit, resolveHybridFusion, dedupePinnedEntries, foldGroupReducer } from './chunk-WL2GDSCV.mjs';
+import { requireKnownConfig, resolveRunnableConfig, createEngineCore, startEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, buildArchiveFromMemory, indexMetadataOf, encodeIndexConfiguration, archiveStream, applyIndexEntry, applyDeleteEntry, requireConfigurationWithinSizeLimit, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, memoryCheckpointStore, readSnapshotArchive, createByteReader, openChecksummedEnvelope, loadPartitionSegments, readListedFile, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, crc32Init, crc32Final, crc32Update, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-HH6ALOUZ.mjs';
+import { now, listBindingOf, requireSurfaceFormsForPartialFields, queryBindingOf, hitsKeptPerGroup, clampLimit, resolveHybridFusion, dedupePinnedEntries, foldGroupReducer } from './chunk-G7IP3UDZ.mjs';
 import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError } from './chunk-GCM3JFVA.mjs';
 import { providedDocId, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET } from './chunk-BT62MUM5.mjs';
-import { generateId, decodeVectorFilePayload, bytesToVectors, isDead, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-YOVS4EV5.mjs';
-import { oversampledShardSize, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, sortModesOf, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, sortSignatureEntry, filterTestCount, fnv1aUint32s, mergePartitionStats } from './chunk-NAMGDK45.mjs';
+import { generateId, decodeVectorFilePayload, bytesToVectors, isDead, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-DFFQOA7S.mjs';
+import { oversampledShardSize, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, sortModesOf, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, sortSignatureEntry, filterTestCount, fnv1aUint32s, mergePartitionStats } from './chunk-D4EF7J3I.mjs';
 import { getLanguage } from './chunk-4MQ5F4IL.mjs';
 import { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, DEFAULT_PAGE_SIZE, MAX_SUGGEST_SCATTER_LIMIT, MAX_INDEX_NAME_LENGTH, MAX_FILTER_DEPTH, MAX_FILTER_TESTS, MAX_SORT_FIELDS, MAX_DOC_ID_LENGTH, MAX_CURSOR_LENGTH, MAX_TOLERANCE, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, INDEX_NAME_PATTERN, MAX_PREFIX_LENGTH, RESULT_WINDOW, MAX_FILTER_ARRAY_SIZE } from './chunk-V3B24XR7.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-AMGDG4ZJ.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
 import './chunk-2E35UM3G.mjs';
-import './chunk-7ODNRREZ.mjs';
-import './chunk-AIUOAN7Y.mjs';
-import './chunk-UOJIV2NG.mjs';
+import { isPatternTolerance } from './chunk-4344I4MR.mjs';
+import './chunk-PJU6EF22.mjs';
+import './chunk-NO3ABFLE.mjs';
 import { validateSchema, requireCreatableSchema, encodeDocument, MAX_STORED_VECTOR_DIMENSION, MIN_POLYGON_POINTS, isLatitude, MAX_LATITUDE_DEGREES, isLongitude, MAX_LONGITUDE_DEGREES, MAX_NESTING_DEPTH } from './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-U2BKYEC7.mjs';
 import { compareCodePoints, toComparableSortValue, compareComparableKeys, isSortMode, SORT_MODES, exceedsCodePoints, compareSortValues } from './chunk-IBR6634K.mjs';
 import './chunk-POWOTUKJ.mjs';
@@ -6781,6 +6782,12 @@ function validateLeafOperator(opKey, opValue, leafLabel, errorCode) {
     validateBooleanOperand(opValue, opLabel, errorCode);
     return;
   }
+  if (opKey === "tolerance") {
+    if (!isPatternTolerance(opValue)) {
+      throwInvalid(errorCode, `Invalid payload: "${opLabel}" must be 0, 1, 2, or "auto"`);
+    }
+    return;
+  }
   if (opKey === "in" || opKey === "nin") {
     validateStringList(opValue, opLabel, errorCode);
     return;

package/dist/{engine-DcGSd5vh.d.ts → engine-BjPBzWkA.d.ts}

@@ -1,5 +1,5 @@
 import { E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { B as BatchResult, I as IndexInfo, g as IndexStats, P as PartitionStatsResult, L as ListParams, h as ListResult, Q as QueryParams, e as QueryResult, j as PreflightResult, k as SuggestParams, l as SuggestResult, D as DocumentImportResult, M as MemoryStats, V as VectorMaintenanceResult, m as NarsilEventMap } from './memory-M9kPmYP8.js';
+import { B as BatchResult, I as IndexInfo, g as IndexStats, P as PartitionStatsResult, L as ListParams, h as ListResult, Q as QueryParams, e as QueryResult, j as PreflightResult, k as SuggestParams, l as SuggestResult, D as DocumentImportResult, M as MemoryStats, V as VectorMaintenanceResult, m as NarsilEventMap } from './memory-DW3OJ0im.js';
 import { A as AnyDocument, a as InsertOptions, W as WriteOptions, I as IndexConfig, P as PartitionConfig } from './schema-DgyDijhf.js';
 
 /**

package/dist/index.browser.mjs

@@ -2631,6 +2631,7 @@ var MATCHER_SIMULATION_BYTES_PER_POSITION = 16;
 var MATCHER_STATE_OVERHEAD_BYTES = 96;
 var PATTERN_WORK_FLUSH_UNITS = 65536;
 var PATTERN_RUN_CODE_POINTS = 3;
+var MAX_PATTERN_TOLERANCE = 2;
 var PATTERN_TEST_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "contains"];
 var PATTERN_EXPRESSION_OPERATORS = ["wildcard", "regex"];
 
@@ -3433,8 +3434,12 @@ function fuzzyTermMatches(queryTerm, indexTerm, tolerance, prefixLength) {
   return boundedLevenshtein(queryTerm, indexTerm, tolerance).withinTolerance;
 }
 function boundedLevenshtein(a, b, tolerance) {
-  if (tolerance < 0) return { distance: -1, withinTolerance: false };
-  if (a === b) return { distance: 0, withinTolerance: true };
+  if (tolerance < 0) return { distance: -1, withinTolerance: false, cells: 0 };
+  if (a === b) return { distance: 0, withinTolerance: true, cells: 0 };
+  return tabulatedLevenshtein(a, b, tolerance);
+}
+function tabulatedLevenshtein(a, b, tolerance) {
+  if (tolerance < 0) return { distance: -1, withinTolerance: false, cells: 0 };
   if (hasSurrogate(a) || hasSurrogate(b)) return bandedDistance(Array.from(a), Array.from(b), tolerance);
   return bandedDistance(a, b, tolerance);
 }
@@ -3442,30 +3447,32 @@ function bandedDistance(a, b, tolerance) {
   const m = a.length;
   const n = b.length;
   const beyond = tolerance + 1;
-  if (Math.abs(m - n) > tolerance) return { distance: beyond, withinTolerance: false };
+  if (Math.abs(m - n) > tolerance) return { distance: beyond, withinTolerance: false, cells: 0 };
   let previous = new Uint32Array(n + 1).fill(beyond);
   let current = new Uint32Array(n + 1).fill(beyond);
   const firstRowEnd = Math.min(n, tolerance);
   for (let j = 0; j <= firstRowEnd; j++) previous[j] = j;
+  let cells = 0;
   for (let i = 1; i <= m; i++) {
     const low = Math.max(1, i - tolerance);
     const high = Math.min(n, i + tolerance);
     current[low - 1] = low === 1 ? i : beyond;
     let rowMin = current[low - 1];
     const character = a[i - 1];
+    if (high >= low) cells += high - low + 1;
     for (let j = low; j <= high; j++) {
       const substitution = previous[j - 1] + (character === b[j - 1] ? 0 : 1);
       const cell = Math.min(previous[j] + 1, current[j - 1] + 1, substitution, beyond);
       current[j] = cell;
       if (cell < rowMin) rowMin = cell;
     }
-    if (rowMin > tolerance) return { distance: beyond, withinTolerance: false };
+    if (rowMin > tolerance) return { distance: beyond, withinTolerance: false, cells };
     const finished = previous;
     previous = current;
     current = finished;
   }
   const distance = previous[n];
-  return { distance, withinTolerance: distance <= tolerance };
+  return { distance, withinTolerance: distance <= tolerance, cells };
 }
 
 // src/core/posting-list.ts
@@ -5732,6 +5739,43 @@ var MAX_FILTER_TESTS = 1024;
 var MAX_FILTER_ARRAY_SIZE = 65536;
 var GEO_UNIT_METRES = { km: 1e3, mi: 1609.344, m: 1 };
 
+// src/core/pattern-index/typo-runs.ts
+var BASIC_PLANE_LAST = 65535;
+function isPatternTolerance(value) {
+  if (value === "auto") return true;
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= MAX_PATTERN_TOLERANCE;
+}
+function foldTypoText(text, host) {
+  const folded = [];
+  let longestFold = 0;
+  for (let at = 0; at < text.length; at++) {
+    const codePoint = text.codePointAt(at) ?? 0;
+    if (codePoint > BASIC_PLANE_LAST) at++;
+    const before = folded.length;
+    host.appendFoldedCodePoint(codePoint, folded);
+    longestFold = Math.max(longestFold, folded.length - before);
+  }
+  return { folded, longestFold };
+}
+function distinctTypoRuns(text, limit) {
+  const { folded } = text;
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (let at = 0; at + PATTERN_RUN_CODE_POINTS <= folded.length && seen.size < limit; at++) {
+    const key = String.fromCodePoint(folded[at], folded[at + 1], folded[at + 2]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    runs.push(folded[at], folded[at + 1], folded[at + 2]);
+  }
+  return runs;
+}
+function typoRunsNeeded(tolerance, longestFold) {
+  return tolerance * (2 + longestFold) + 1;
+}
+function distinctTypoRunCount(text, limit) {
+  return distinctTypoRuns(text, limit).length / PATTERN_RUN_CODE_POINTS;
+}
+
 // src/filters/pattern-tests.ts
 function excluding(context, fieldPath, excluded) {
   const universe = bitsetAnd(context.presentBitset(fieldPath), context.allDocIdsBitset);
@@ -5745,12 +5789,13 @@ function textsOf2(operand) {
 }
 function evaluatePatternTests(fieldPath, filter, context, bitsets) {
   const caseFold = filter.caseFold === true;
-  const matching = (operator, texts) => {
+  const matching = (operator, texts, tolerance = 0) => {
     const into = createBitSet(context.capacity);
-    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, into);
+    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, tolerance, into);
     return into;
   };
-  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq]));
+  const eqTolerance = isPatternTolerance(filter.tolerance) ? filter.tolerance : 0;
+  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq], eqTolerance));
   if (typeof filter.ne === "string") bitsets.push(excluding(context, fieldPath, matching("eq", [filter.ne])));
   if (filter.in !== void 0) bitsets.push(matching("eq", textsOf2(filter.in)));
   if (filter.nin !== void 0) bitsets.push(excluding(context, fieldPath, matching("eq", textsOf2(filter.nin))));
@@ -5806,7 +5851,7 @@ function elementBits(context, fieldPath, parsed, value) {
   const { capacity } = context;
   if (parsed.pattern) {
     const matches = createBitSet(capacity);
-    context.matchPattern(fieldPath, "eq", value, false, matches);
+    context.matchPattern(fieldPath, "eq", value, false, 0, matches);
     return matches;
   }
   if (typeof value === "number")
@@ -5819,7 +5864,7 @@ function anyElementBits(context, fieldPath, parsed, values) {
   const { capacity } = context;
   const union = createBitSet(capacity);
   if (parsed.pattern) {
-    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, union);
+    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, 0, union);
     return union;
   }
   if (parsed.base === "enum[]") {
@@ -5966,6 +6011,7 @@ var FIELD_FILTER_OPERATORS = [
   "wildcard",
   "regex",
   "caseFold",
+  "tolerance",
   "containsAll",
   "matchesAny",
   "size",
@@ -6230,6 +6276,7 @@ function requirePatternOperands(fieldPath, filter, type) {
     requirePatternField(fieldPath, "caseFold", type);
   }
   requireExpressions(fieldPath, filter, type);
+  if (filter.tolerance !== void 0) requirePatternField(fieldPath, "tolerance", type);
   if (parsedTypeOf(type)?.pattern !== true) return;
   const caseFold = filter.caseFold === true;
   for (const operator of PATTERN_TEST_OPERATORS) {
@@ -6247,6 +6294,31 @@ function requirePatternOperands(fieldPath, filter, type) {
       if (typeof text === "string") requirePatternText(fieldPath, operator, text, false);
     }
   }
+  requireTolerance(fieldPath, filter);
+}
+function requireTolerance(fieldPath, filter) {
+  const { tolerance, eq } = filter;
+  if (tolerance === void 0) return;
+  if (!isPatternTolerance(tolerance)) {
+    invalid(`"tolerance" on field "${fieldPath}" must be 0, 1, 2, or "auto"`, fieldPath, "tolerance");
+  }
+  if (typeof eq !== "string") {
+    invalid(
+      `"tolerance" applies only to an "eq" test, while the filter on field "${fieldPath}" sets no "eq" with text`,
+      fieldPath,
+      "tolerance"
+    );
+  }
+  if (tolerance === 0 || tolerance === "auto") return;
+  const text = foldTypoText(eq, PATTERN_HOST);
+  const requiredRuns = typoRunsNeeded(tolerance, text.longestFold);
+  const distinctRuns = distinctTypoRunCount(text, requiredRuns);
+  if (distinctRuns >= requiredRuns) return;
+  throw new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `A tolerance of ${tolerance} on "eq" of pattern field "${fieldPath}" needs ${requiredRuns} distinct runs of three code points in the case fold of the text, while the text holds ${distinctRuns}. Lengthen the text, lower the tolerance, or set it to "auto"`,
+    { fieldPath, operator: "tolerance", requiredRuns, distinctRuns }
+  );
 }
 function requireWellFormedText(fieldPath, filter) {
   for (const [operator, operand] of Object.entries(filter)) {
@@ -6268,6 +6340,7 @@ var TEXT_OPERATORS = ["startsWith", "endsWith"];
 var EQUALITY_OPERATORS = ["eq", "ne"];
 var LIST_OPERATORS = ["in", "nin"];
 var GEO_OPERATORS = ["radius", "polygon"];
+var TEST_MODIFIERS = /* @__PURE__ */ new Set(["caseFold", "tolerance"]);
 function invalidShape(message) {
   throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message);
 }
@@ -6361,7 +6434,7 @@ function requireValidOperands(fieldPath, filter, type) {
 function testsIn(filter) {
   let tests = 0;
   for (const [operator, operand] of Object.entries(filter)) {
-    if (operator === "caseFold") continue;
+    if (TEST_MODIFIERS.has(operator)) continue;
     tests += operator === "size" && isObjectRecord(operand) ? Math.max(1, Object.keys(operand).length) : 1;
   }
   return Math.max(1, tests);
@@ -7129,13 +7202,14 @@ function buildFilterContext(state, schema, meter) {
     sizeIndex: (fieldPath) => state.sizeIndexes.get(fieldPath),
     textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
     isPatternField: (fieldPath) => patternFields.has(fieldPath),
-    matchPattern: (fieldPath, operator, text, caseFold, into) => {
+    matchPattern: (fieldPath, operator, text, caseFold, tolerance, into) => {
       const index = state.patternIndexes.get(fieldPath);
       if (index === void 0) return;
       requirePatternSearch(fieldPath).matchInto({
         operator,
         text,
         caseFold,
+        tolerance,
         index,
         matches: into,
         meter,

package/dist/index.d.ts

@@ -4,11 +4,11 @@ import { P as PartialWordSearch } from './partial-words-DTIHO8G4.js';
 import { P as PatternSearch } from './pattern-Cledccbl.js';
 import { L as LanguageModule } from './language-DB8KG1z5.js';
 export { T as TokenizerConfig } from './language-DB8KG1z5.js';
-export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, n as ComparisonFilter, D as DocumentImportResult, o as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, p as FacetResult, q as FieldFilter, r as FilterExpression, G as GeoFilter, s as GeoPolygonFilter, t as GeoRadiusFilter, u as GroupConfig, v as GroupReducer, w as GroupResult, H as HighlightConfig, x as HighlightMatch, y as Hit, z as HybridConfig, I as IndexInfo, g as IndexStats, L as ListParams, h as ListResult, J as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, f as NarsilEventHandlers, m as NarsilEventMap, P as PartitionStatsResult, j as PreflightResult, K as PresenceFilter, O as ProcessMemoryReport, R as QueryCoverage, Q as QueryParams, e as QueryResult, T as ScoreComponents, U as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, W as SortField, X as SortSpec, Y as StringFilter, k as SuggestParams, l as SuggestResult, Z as TermMatchPolicy, V as VectorMaintenanceResult, _ as VectorQueryConfig, $ as WorkerCopyReport, i as isNarsilError } from './memory-M9kPmYP8.js';
-import { N as NarsilConfig } from './config-C1kbq1X2.js';
-export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as IndexLifecycleConfig, b as InsertContext, M as MainCopyQueries, c as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, d as StaleAnalysis, U as UpdateContext, W as WorkerConfig, e as WorkerContext } from './config-C1kbq1X2.js';
-import { N as Narsil } from './engine-DcGSd5vh.js';
-export { B as ByteSource, D as DocumentWriteOperations, I as IndexLifecycleOperations } from './engine-DcGSd5vh.js';
+export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, n as ComparisonFilter, D as DocumentImportResult, o as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, p as FacetResult, q as FieldFilter, r as FilterExpression, G as GeoFilter, s as GeoPolygonFilter, t as GeoRadiusFilter, u as GroupConfig, v as GroupReducer, w as GroupResult, H as HighlightConfig, x as HighlightMatch, y as Hit, z as HybridConfig, I as IndexInfo, g as IndexStats, L as ListParams, h as ListResult, J as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, f as NarsilEventHandlers, m as NarsilEventMap, P as PartitionStatsResult, j as PreflightResult, K as PresenceFilter, O as ProcessMemoryReport, R as QueryCoverage, Q as QueryParams, e as QueryResult, T as ScoreComponents, U as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, W as SortField, X as SortSpec, Y as StringFilter, k as SuggestParams, l as SuggestResult, Z as TermMatchPolicy, V as VectorMaintenanceResult, _ as VectorQueryConfig, $ as WorkerCopyReport, i as isNarsilError } from './memory-DW3OJ0im.js';
+import { N as NarsilConfig } from './config-DTe5EbWW.js';
+export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as IndexLifecycleConfig, b as InsertContext, M as MainCopyQueries, c as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, d as StaleAnalysis, U as UpdateContext, W as WorkerConfig, e as WorkerContext } from './config-DTe5EbWW.js';
+import { N as Narsil } from './engine-BjPBzWkA.js';
+export { B as ByteSource, D as DocumentWriteOperations, I as IndexLifecycleOperations } from './engine-BjPBzWkA.js';
 export { E as EmbeddingAdapter, I as InvalidationAdapter, a as InvalidationEvent, b as PartitionStatistics, P as PersistenceAdapter } from './adapters-79OIa4xm.js';
 export { i as isSimdAvailable } from './simd-DW5AtJ6B.js';
 

package/dist/index.mjs

@@ -1,20 +1,21 @@
-export { VERSION, createNarsil } from './chunk-LOARLB4F.mjs';
-import './chunk-WL2GDSCV.mjs';
+export { VERSION, createNarsil } from './chunk-HH6ALOUZ.mjs';
+import './chunk-G7IP3UDZ.mjs';
 import './chunk-GCM3JFVA.mjs';
 import './chunk-BT62MUM5.mjs';
-export { getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerPartialWordSearch, registerStopWords, registerTokenizer } from './chunk-YOVS4EV5.mjs';
-export { registerPatternSearch } from './chunk-NAMGDK45.mjs';
+export { getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerPartialWordSearch, registerStopWords, registerTokenizer } from './chunk-DFFQOA7S.mjs';
+export { registerPatternSearch } from './chunk-D4EF7J3I.mjs';
 export { getLanguage, registerLanguage } from './chunk-4MQ5F4IL.mjs';
 import './chunk-V3B24XR7.mjs';
 import './chunk-TGP5M5R7.mjs';
 export { isSimdAvailable } from './chunk-AMGDG4ZJ.mjs';
 import './chunk-ZJ4CSAB2.mjs';
 import './chunk-2E35UM3G.mjs';
-import './chunk-7ODNRREZ.mjs';
-import './chunk-AIUOAN7Y.mjs';
-export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-UOJIV2NG.mjs';
+import './chunk-4344I4MR.mjs';
+import './chunk-PJU6EF22.mjs';
+export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-NO3ABFLE.mjs';
 import './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-U2BKYEC7.mjs';
 import './chunk-IBR6634K.mjs';
 import './chunk-POWOTUKJ.mjs';

package/dist/{memory-M9kPmYP8.d.ts → memory-DW3OJ0im.d.ts}

@@ -140,6 +140,33 @@ type StringFilter = Pick<ComparisonFilter, 'eq' | 'ne'> & {
      * `ss`.
      */
     caseFold?: boolean;
+    /**
+     * This lets the `eq` test of a pattern field match a value within this many
+     * edits of the text, so a test for `INV-2O24` with a tolerance of 1 matches
+     * `INV-2024`. An edit inserts, deletes, or replaces one code point, so a
+     * swap of two neighbouring code points counts as two edits. With `caseFold`,
+     * the engine counts the edits between the case folds of the value and the
+     * text. The tolerance applies to `eq` alone, so the other tests of the field
+     * still compare exactly.
+     *
+     * The engine takes its candidates from the pattern index, so the case fold
+     * of the text has to hold enough distinct runs of three code points. For a
+     * tolerance of `k`, the engine needs `k × (2 + f) + 1` runs, where `f` is
+     * the number of code points in the longest case fold among the text's code
+     * points, which is 1 for most text. A tolerance of 1 on `INV-2O24`
+     * therefore needs 4 of its 6 runs, while a tolerance of 2 needs 7. Under
+     * `'auto'`, the engine uses 2 where the text holds enough runs for 2,
+     * otherwise 1 where it holds enough for 1, and otherwise 0.
+     *
+     * The engine throws `SEARCH_INVALID_FILTER` for a tolerance of 1 or 2 on a
+     * text with too few runs, stating how many runs that tolerance needs. It
+     * throws the same error for any other tolerance, for a tolerance on a field
+     * that is not a pattern field, and for a tolerance in a filter without an
+     * `eq` test. Towards the pattern work cap, it counts one unit for each cell
+     * that it fills in the table of edit distances between the text and a
+     * value.
+     */
+    tolerance?: 0 | 1 | 2 | 'auto';
 };
 /**
  * Tests the contents of a list field, which is a `number[]`, `boolean[]`,

package/dist/partial-words.mjs

@@ -1,7 +1,8 @@
-import { partialWordSearchModule } from './chunk-AIUOAN7Y.mjs';
-import './chunk-UOJIV2NG.mjs';
+import { partialWordSearchModule } from './chunk-PJU6EF22.mjs';
+import './chunk-NO3ABFLE.mjs';
 import './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-IBR6634K.mjs';
 import './chunk-I64LXKO3.mjs';
 

package/dist/pattern.mjs

@@ -1,4 +1,5 @@
-import { patternSearchModule } from './chunk-7ODNRREZ.mjs';
+import { patternSearchModule } from './chunk-4344I4MR.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-I64LXKO3.mjs';
 
 // src/pattern/index.ts

package/dist/persistence/durability/checkpoint-worker.mjs

@@ -1,20 +1,21 @@
-import { CHECKPOINT_WORKER_HEARTBEAT_MS, createDurableDirectory, writeCheckpointSegments, directoryCheckpointStore } from '../../chunk-LOARLB4F.mjs';
-import '../../chunk-WL2GDSCV.mjs';
+import { CHECKPOINT_WORKER_HEARTBEAT_MS, createDurableDirectory, writeCheckpointSegments, directoryCheckpointStore } from '../../chunk-HH6ALOUZ.mjs';
+import '../../chunk-G7IP3UDZ.mjs';
 import '../../chunk-GCM3JFVA.mjs';
 import '../../chunk-BT62MUM5.mjs';
-import '../../chunk-YOVS4EV5.mjs';
-import '../../chunk-NAMGDK45.mjs';
+import '../../chunk-DFFQOA7S.mjs';
+import '../../chunk-D4EF7J3I.mjs';
 import '../../chunk-4MQ5F4IL.mjs';
 import '../../chunk-V3B24XR7.mjs';
 import '../../chunk-TGP5M5R7.mjs';
 import '../../chunk-AMGDG4ZJ.mjs';
 import '../../chunk-ZJ4CSAB2.mjs';
 import '../../chunk-2E35UM3G.mjs';
-import '../../chunk-7ODNRREZ.mjs';
-import '../../chunk-AIUOAN7Y.mjs';
-import '../../chunk-UOJIV2NG.mjs';
+import '../../chunk-4344I4MR.mjs';
+import '../../chunk-PJU6EF22.mjs';
+import '../../chunk-NO3ABFLE.mjs';
 import '../../chunk-356UOTK2.mjs';
 import '../../chunk-KEHK2O6P.mjs';
+import '../../chunk-GES7U2PM.mjs';
 import '../../chunk-U2BKYEC7.mjs';
 import '../../chunk-IBR6634K.mjs';
 import '../../chunk-POWOTUKJ.mjs';

package/dist/react.d.ts

@@ -1,10 +1,10 @@
-import { N as NarsilError, L as ListParams, h as ListResult, I as IndexInfo, g as IndexStats, Q as QueryParams, j as PreflightResult, e as QueryResult, k as SuggestParams, l as SuggestResult } from './memory-M9kPmYP8.js';
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-M9kPmYP8.js';
-import { e as TaskRecord, d as TaskProgress, b as ImportResult, c as TaskListQuery, T as TaskListPage } from './tasks-A8se0J98.js';
-export { I as ImportError, f as TaskStatus, g as TaskType } from './tasks-A8se0J98.js';
+import { N as NarsilError, L as ListParams, h as ListResult, I as IndexInfo, g as IndexStats, Q as QueryParams, j as PreflightResult, e as QueryResult, k as SuggestParams, l as SuggestResult } from './memory-DW3OJ0im.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-DW3OJ0im.js';
+import { e as TaskRecord, d as TaskProgress, b as ImportResult, c as TaskListQuery, T as TaskListPage } from './tasks-BTbwBqar.js';
+export { I as ImportError, f as TaskStatus, g as TaskType } from './tasks-BTbwBqar.js';
 import { ReactNode, ReactElement } from 'react';
-import { N as Narsil } from './engine-DcGSd5vh.js';
-import { N as NarsilClient, I as ImportSource } from './client-D4sXFS9f.js';
+import { N as Narsil } from './engine-BjPBzWkA.js';
+import { N as NarsilClient, I as ImportSource } from './client-ZXcbSViH.js';
 import { A as AnyDocument } from './schema-DgyDijhf.js';
 import './adapters-79OIa4xm.js';
 

package/dist/server.d.ts

@@ -1,13 +1,13 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-M9kPmYP8.js';
-import { b as ServerOptions, N as NarsilServer } from './capabilities-BHNksicw.js';
-export { A as ASYNC_IMPORT_CAPABILITY, C as CorsOptions, D as DOCUMENT_EXPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, O as OnRequestHook, R as REBUILD_ANALYSIS_CAPABILITY, c as RequestContext, d as RequestDenial, S as SERVER_CAPABILITIES, e as ServerLimits, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-BHNksicw.js';
-import { N as Narsil } from './engine-DcGSd5vh.js';
-import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-A8se0J98.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, i as CreateIndexRequest, H as HttpIndexConfig, I as ImportError, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, f as TaskStatus, g as TaskType } from './tasks-A8se0J98.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-DW3OJ0im.js';
+import { b as ServerOptions, N as NarsilServer } from './capabilities-1lEYL3WK.js';
+export { A as ASYNC_IMPORT_CAPABILITY, C as CorsOptions, D as DOCUMENT_EXPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, O as OnRequestHook, R as REBUILD_ANALYSIS_CAPABILITY, c as RequestContext, d as RequestDenial, S as SERVER_CAPABILITIES, e as ServerLimits, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-1lEYL3WK.js';
+import { N as Narsil } from './engine-BjPBzWkA.js';
+import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-BTbwBqar.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, i as CreateIndexRequest, H as HttpIndexConfig, I as ImportError, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, f as TaskStatus, g as TaskType } from './tasks-BTbwBqar.js';
 import './schema-DgyDijhf.js';
 import './adapters-79OIa4xm.js';
-import './config-B-GRonqw.js';
-import './config-C1kbq1X2.js';
+import './config-DHL2KsfD.js';
+import './config-DTe5EbWW.js';
 import './types-ChrVy4lH.js';
 import './types-Cb9kiY5P.js';
 

package/dist/{tasks-A8se0J98.d.ts → tasks-BTbwBqar.d.ts}

@@ -1,4 +1,4 @@
-import { M as MemoryStats } from './memory-M9kPmYP8.js';
+import { M as MemoryStats } from './memory-DW3OJ0im.js';
 
 /** Declarative index configuration accepted over HTTP. Function-valued engine
  * options (custom tokenizer, stopWords-as-function, group reducer, embedding

package/dist/{thread-BSIKT6ED.mjs → thread-YOTNJEVY.mjs}

@@ -1,13 +1,14 @@
 import { loadUWebSockets, childAppOf, createRouteRunner, corsHeaderReader, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, versionReport, statusLine, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery, refuseRegex } from './chunk-BT6BI4GV.mjs';
-import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-WL2GDSCV.mjs';
-import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-NAMGDK45.mjs';
+import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-G7IP3UDZ.mjs';
+import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-D4EF7J3I.mjs';
 import './chunk-V3B24XR7.mjs';
 import './chunk-ZJ4CSAB2.mjs';
 import './chunk-2E35UM3G.mjs';
-import './chunk-7ODNRREZ.mjs';
-import './chunk-UOJIV2NG.mjs';
+import './chunk-4344I4MR.mjs';
+import './chunk-NO3ABFLE.mjs';
 import { extractVectorFieldsFromSchema } from './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
+import './chunk-GES7U2PM.mjs';
 import './chunk-IBR6634K.mjs';
 import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 

package/dist/workers/entry.mjs

@@ -18,7 +18,7 @@ async function importBootstrapModule(moduleUrl) {
   await import(moduleUrl);
 }
 async function stopServingRequests() {
-  const { closeRequestThread } = await import('../thread-BSIKT6ED.mjs');
+  const { closeRequestThread } = await import('../thread-YOTNJEVY.mjs');
   closeRequestThread();
 }
 function holdsCopies(executor) {
@@ -49,7 +49,7 @@ function createActionHandler(executor) {
         if (!holdsCopies(executor)) {
           throw new NarsilError(ErrorCodes.CONFIG_INVALID, "This executor holds no copies to answer requests from");
         }
-        const starting = import('../thread-BSIKT6ED.mjs').then(
+        const starting = import('../thread-YOTNJEVY.mjs').then(
           ({ serveRequests }) => serveRequests(executor, action.settings)
         );
         serving.start = starting.then(
@@ -102,7 +102,7 @@ async function setup() {
   } catch {
     parentPort = null;
   }
-  const { createDirectExecutor } = await import('../direct-executor-AVNWB73C.mjs');
+  const { createDirectExecutor } = await import('../direct-executor-Q7PNCGZB.mjs');
   const handleAction = createActionHandler(createDirectExecutor({ threadSlot }));
   if (parentPort) {
     const port = parentPort;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delali/narsil",
-  "version": "0.3.1-next.75",
+  "version": "0.3.1-next.76",
   "type": "module",
   "description": "Distributed search engine with full-text, vector, hybrid, and geosearch. One engine, embedded or on a server, with a cross-language .nrsl format.",
   "author": "Delali (https://sondelali.com)",
@@ -240,11 +240,11 @@
     }
   },
   "optionalDependencies": {
-    "@delali/narsil-native-darwin-arm64": "0.3.1-next.75",
-    "@delali/narsil-native-darwin-x64": "0.3.1-next.75",
-    "@delali/narsil-native-linux-arm64": "0.3.1-next.75",
-    "@delali/narsil-native-linux-x64": "0.3.1-next.75",
-    "@delali/narsil-native-win32-arm64": "0.3.1-next.75",
-    "@delali/narsil-native-win32-x64": "0.3.1-next.75"
+    "@delali/narsil-native-darwin-arm64": "0.3.1-next.76",
+    "@delali/narsil-native-darwin-x64": "0.3.1-next.76",
+    "@delali/narsil-native-linux-arm64": "0.3.1-next.76",
+    "@delali/narsil-native-linux-x64": "0.3.1-next.76",
+    "@delali/narsil-native-win32-arm64": "0.3.1-next.76",
+    "@delali/narsil-native-win32-x64": "0.3.1-next.76"
   }
 }