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

package/dist/index.browser.mjs

@@ -852,7 +852,7 @@ function platformPatternSearch() {
 // src/core/pattern-index/registry.ts
 var registered2 = null;
 function isPatternSearchModule(value) {
-  return value !== null && typeof value === "object" && value.name === "pattern" && "createIndex" in value && typeof value.createIndex === "function" && "readArrays" in value && typeof value.readArrays === "function" && "mergeArrays" in value && typeof value.mergeArrays === "function" && "matchInto" in value && typeof value.matchInto === "function";
+  return value !== null && typeof value === "object" && value.name === "pattern" && "createIndex" in value && typeof value.createIndex === "function" && "readArrays" in value && typeof value.readArrays === "function" && "mergeArrays" in value && typeof value.mergeArrays === "function" && "matchInto" in value && typeof value.matchInto === "function" && "checkExpression" in value && typeof value.checkExpression === "function" && "expressionFootprint" in value && typeof value.expressionFootprint === "function";
 }
 function registerPatternSearch(module) {
   if (!isPatternSearchModule(module)) {
@@ -2631,7 +2631,9 @@ 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"];
 
 // src/geo/constants.ts
 var DEG_TO_RAD = Math.PI / 180;
@@ -3432,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);
 }
@@ -3441,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
@@ -4406,7 +4414,24 @@ function computeFacets(state, matched, config, schema) {
 }
 
 // src/core/pattern-index/host.ts
-var PATTERN_HOST = { appendFoldedCodePoint };
+var NO_SOURCES = [];
+var foldSources = null;
+function sourcesByFold() {
+  if (foldSources !== null) return foldSources;
+  const sources = /* @__PURE__ */ new Map();
+  const add = (source, folded) => {
+    const known = sources.get(folded);
+    if (known === void 0) sources.set(folded, [source]);
+    else known.push(source);
+  };
+  for (const [source, folded] of singleFoldTable()) add(source, folded);
+  foldSources = sources;
+  return sources;
+}
+function singleFoldSources(folded) {
+  return sourcesByFold().get(folded) ?? NO_SOURCES;
+}
+var PATTERN_HOST = { appendFoldedCodePoint, singleFoldSources };
 function patternIndexOf(indexes, fieldPath) {
   let index = indexes.get(fieldPath);
   if (index === void 0) {
@@ -5714,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);
@@ -5727,18 +5789,21 @@ 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))));
   if (typeof filter.startsWith === "string") bitsets.push(matching("startsWith", [filter.startsWith]));
   if (typeof filter.endsWith === "string") bitsets.push(matching("endsWith", [filter.endsWith]));
   if (typeof filter.contains === "string") bitsets.push(matching("contains", [filter.contains]));
+  if (typeof filter.wildcard === "string") bitsets.push(matching("wildcard", [filter.wildcard]));
+  if (typeof filter.regex === "string") bitsets.push(matching("regex", [filter.regex]));
 }
 
 // src/filters/field-tests.ts
@@ -5786,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")
@@ -5799,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[]") {
@@ -5943,7 +6008,10 @@ var FIELD_FILTER_OPERATORS = [
   "startsWith",
   "endsWith",
   "contains",
+  "wildcard",
+  "regex",
   "caseFold",
+  "tolerance",
   "containsAll",
   "matchesAny",
   "size",
@@ -6158,14 +6226,16 @@ function requirePatternField(fieldPath, operator, type) {
     operator
   );
 }
+function requireTextLength(fieldPath, operator, text) {
+  if (!exceedsCodePoints(text, MAX_PATTERN_TEXT_CODE_POINTS)) return;
+  invalid(
+    `The text of "${operator}" on pattern field "${fieldPath}" holds more than ${MAX_PATTERN_TEXT_CODE_POINTS} code points`,
+    fieldPath,
+    operator
+  );
+}
 function requirePatternText(fieldPath, operator, text, caseFold) {
-  if (exceedsCodePoints(text, MAX_PATTERN_TEXT_CODE_POINTS)) {
-    invalid(
-      `The text of "${operator}" on pattern field "${fieldPath}" holds more than ${MAX_PATTERN_TEXT_CODE_POINTS} code points`,
-      fieldPath,
-      operator
-    );
-  }
+  requireTextLength(fieldPath, operator, text);
   if (caseFold && foldedCodePointCount(text) > MAX_PATTERN_POSITIONS) {
     invalid(
       `The text of "${operator}" on pattern field "${fieldPath}" has a case fold of more than ${MAX_PATTERN_POSITIONS} code points, while a pattern holds at most ${MAX_PATTERN_POSITIONS} positions`,
@@ -6175,6 +6245,23 @@ function requirePatternText(fieldPath, operator, text, caseFold) {
   }
 }
 var ELEMENT_OPERATORS2 = ["matchesAny", "containsAll"];
+function requireExpressions(fieldPath, filter, type) {
+  for (const operator of PATTERN_EXPRESSION_OPERATORS) {
+    const pattern = filter[operator];
+    if (pattern === void 0) continue;
+    if (typeof pattern !== "string")
+      invalid(`"${operator}" on field "${fieldPath}" must be a string`, fieldPath, operator);
+    requirePatternField(fieldPath, operator, type);
+    requireTextLength(fieldPath, operator, pattern);
+    requirePatternSearch(fieldPath).checkExpression(
+      operator,
+      pattern,
+      filter.caseFold === true,
+      fieldPath,
+      PATTERN_HOST
+    );
+  }
+}
 function requirePatternOperands(fieldPath, filter, type) {
   if (filter.contains !== void 0) {
     if (typeof filter.contains !== "string") {
@@ -6188,6 +6275,8 @@ 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) {
@@ -6205,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)) {
@@ -6226,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);
 }
@@ -6319,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);
@@ -7087,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,
@@ -30653,57 +30769,61 @@ var POSITIONS_PER_WORD = 32;
 function positionWords(positions) {
   return Math.max(1, Math.ceil(positions / POSITIONS_PER_WORD));
 }
-function automatonBytes(positions) {
-  return 2 * positionWords(positions) * Uint32Array.BYTES_PER_ELEMENT + positions * MATCHER_CODE_POINT_BYTES;
-}
 function smallestMatcherBytes(positions) {
-  return automatonBytes(positions) + positions * MATCHER_SIMULATION_BYTES_PER_POSITION + MATCHER_STATE_OVERHEAD_BYTES + positions * Uint32Array.BYTES_PER_ELEMENT;
+  return 2 * positionWords(positions) * Uint32Array.BYTES_PER_ELEMENT + positions * MATCHER_CODE_POINT_BYTES + positions * MATCHER_SIMULATION_BYTES_PER_POSITION + MATCHER_STATE_OVERHEAD_BYTES + positions * Uint32Array.BYTES_PER_ELEMENT;
 }
-function widestPatternSplit(positions) {
-  return Math.max(1, Math.floor(MATCHER_STATE_BUDGET_BYTES / smallestMatcherBytes(positions)));
+function widestPatternSplit(footprintBytes) {
+  return Math.max(1, Math.floor(MATCHER_STATE_BUDGET_BYTES / Math.max(1, footprintBytes)));
 }
 
 // src/core/pattern-index/query-positions.ts
 function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function textPositions(text, caseFold) {
-  if (typeof text !== "string") return 0;
-  return caseFold ? foldedCodePointCount(text) : codePointCount(text);
+function literalFootprint(text, caseFold) {
+  if (typeof text !== "string") return null;
+  return smallestMatcherBytes(caseFold ? foldedCodePointCount(text) : codePointCount(text));
 }
 function larger(left, right) {
   if (left === null) return right;
   if (right === null) return left;
   return Math.max(left, right);
 }
-function largestTestOf(filter) {
+function largestTestOf(filter, module) {
   const caseFold = filter.caseFold === true;
   let largest = null;
   for (const operator of PATTERN_TEST_OPERATORS) {
     const operand = filter[operator];
     if (operand === void 0) continue;
     const texts = Array.isArray(operand) ? operand : [operand];
-    for (const text of texts) largest = larger(largest, textPositions(text, caseFold));
+    for (const text of texts) largest = larger(largest, literalFootprint(text, caseFold));
+  }
+  for (const operator of PATTERN_EXPRESSION_OPERATORS) {
+    const pattern = filter[operator];
+    if (typeof pattern !== "string") continue;
+    largest = larger(largest, module.expressionFootprint(operator, pattern, caseFold, PATTERN_HOST));
   }
   return largest;
 }
-function largestIn(expression, patternFields) {
+function largestIn(expression, patternFields, module) {
   let largest = null;
   if (isRecord6(expression.fields)) {
     for (const [fieldPath, filter] of Object.entries(expression.fields)) {
-      if (patternFields.has(fieldPath) && isRecord6(filter)) largest = larger(largest, largestTestOf(filter));
+      if (patternFields.has(fieldPath) && isRecord6(filter)) largest = larger(largest, largestTestOf(filter, module));
     }
   }
   const nested = [...expression.and ?? [], ...expression.or ?? []];
   if (expression.not !== void 0) nested.push(expression.not);
-  for (const child of nested) largest = larger(largest, largestIn(child, patternFields));
+  for (const child of nested) largest = larger(largest, largestIn(child, patternFields, module));
   return largest;
 }
-function largestPatternTest(expression, schema) {
+function largestPatternFootprint(expression, schema) {
   if (expression === void 0) return null;
+  const module = availablePatternSearch();
+  if (module === null) return null;
   const patternFields = /* @__PURE__ */ new Set();
   for (const { path, pattern } of schemaFieldsOf(schema)) if (pattern) patternFields.add(path);
-  return patternFields.size === 0 ? null : largestIn(expression, patternFields);
+  return patternFields.size === 0 ? null : largestIn(expression, patternFields, module);
 }
 
 // src/engine/orchestration/search.ts
@@ -30770,7 +30890,7 @@ function isWorkCapError(err) {
 function patternSplitWidth(state, indexName, params) {
   const schema = state.indexRegistry.get(indexName)?.config.schema;
   if (schema === void 0) return Number.POSITIVE_INFINITY;
-  const largest = largestPatternTest(params.filters, schema);
+  const largest = largestPatternFootprint(params.filters, schema);
   if (largest === null) return Number.POSITIVE_INFINITY;
   if (typeof SharedArrayBuffer !== "function") return 1;
   return widestPatternSplit(largest);

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-DJEwWoCi.js';
-import { N as NarsilConfig } from './config-DJPH3IQB.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-DJPH3IQB.js';
-import { N as Narsil } from './engine-B8eRPO7m.js';
-export { B as ByteSource, D as DocumentWriteOperations, I as IndexLifecycleOperations } from './engine-B8eRPO7m.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,22 +1,22 @@
-export { VERSION, createNarsil } from './chunk-CUZOX6CN.mjs';
-import './chunk-CTOSGRM7.mjs';
+export { VERSION, createNarsil } from './chunk-HH6ALOUZ.mjs';
+import './chunk-G7IP3UDZ.mjs';
 import './chunk-GCM3JFVA.mjs';
-import './chunk-LX4JERXI.mjs';
-export { getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerPartialWordSearch, registerPatternSearch, registerStopWords, registerTokenizer } from './chunk-BVBIQQKG.mjs';
-import './chunk-VKX2BPXD.mjs';
+import './chunk-BT62MUM5.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-3DDUNI6N.mjs';
+import './chunk-V3B24XR7.mjs';
 import './chunk-TGP5M5R7.mjs';
-export { isSimdAvailable } from './chunk-PO53FV4Q.mjs';
+export { isSimdAvailable } from './chunk-AMGDG4ZJ.mjs';
 import './chunk-ZJ4CSAB2.mjs';
 import './chunk-2E35UM3G.mjs';
-import './chunk-XW25X6AU.mjs';
-import './chunk-ZKRV5M2P.mjs';
-import './chunk-T5ZWEWVD.mjs';
-export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-I23G3IZC.mjs';
-import './chunk-Z3DQPOJQ.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-LJYTW7GT.mjs';
+import './chunk-IBR6634K.mjs';
 import './chunk-POWOTUKJ.mjs';
 export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-I64LXKO3.mjs';

package/dist/invalidation/filesystem.mjs

@@ -1,4 +1,4 @@
-import { compareCodePoints } from '../chunk-LJYTW7GT.mjs';
+import { compareCodePoints } from '../chunk-IBR6634K.mjs';
 import { DEFAULT_POLL_INTERVAL_MS, MARKER_MAX_AGE_MS } from '../chunk-YEO6G2NG.mjs';
 
 // src/invalidation/filesystem.ts

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

@@ -28,33 +28,43 @@ type ComparisonFilter = {
 };
 /**
  * The engine tests a text field against this filter for equality, for a text
- * range, or with the set and prefix tests.
+ * range, or with the set, prefix, and pattern tests.
  *
- * The engine compares each element of a `string[]`, `verbatim[]`, or `enum[]` field, so
- * it matches a document with `eq`, `in`, `startsWith`, `endsWith`, or
- * `contains` where one element passes the test, while it matches a document
- * with `ne` or `nin` where every element differs from the values.
+ * On a `string[]`, `verbatim[]`, or `enum[]` field, the engine tests each
+ * element of the list on its own. A document passes `eq`, `in`, `startsWith`,
+ * `endsWith`, `contains`, `wildcard`, or `regex` when one element passes the
+ * test. However, a document passes `ne` or `nin` only when every element
+ * differs from the values.
  *
  * The engine applies the range tests `gt`, `gte`, `lt`, `lte`, and `between`
- * to a single `string` or `verbatim` field whose type includes `sortable`,
- * while it throws `SEARCH_INVALID_FILTER` for a text range on any other field.
- * It orders the values as a sort on the field does, comparing their case folds
- * first and their raw code points only where the folds are equal.
+ * to a single `string` or `verbatim` field whose type includes `sortable`. It
+ * throws `SEARCH_INVALID_FILTER` for a text range on any other field. It
+ * orders the values as a sort on the field does, so it compares their case
+ * folds first and compares their raw code points only where the folds are
+ * equal.
  *
  * A pattern field is a `verbatim` or `verbatim[]` field, or a `string` or
- * `string[]` field whose type includes `pattern`. On such a field, the engine
- * answers `eq`, `ne`, `in`, `nin`, `startsWith`, `endsWith`, and `contains`
- * from the field's pattern index. `caseFold` applies to each of those tests.
+ * `string[]` field whose type includes `pattern`. On a pattern field, the
+ * engine answers `eq`, `ne`, `in`, `nin`, `startsWith`, `endsWith`,
+ * `contains`, `wildcard`, and `regex` from the field's pattern index, and
+ * `caseFold` applies to each of those tests. The engine compares the code
+ * points of each value as they are stored, with no Unicode normalisation.
+ *
  * On an `enum` or `enum[]` field, the engine answers `eq`, `ne`, `in`, `nin`,
- * `startsWith`, and `endsWith` from the field's index of values. It throws
- * `SEARCH_INVALID_FILTER` for `eq`, `ne`, `in`, `nin`, `startsWith`, or
- * `endsWith` on a `string` or `string[]` field whose type leaves out
- * `pattern`, because such a field keeps no index of whole values.
- * The engine compares the code points of each value as stored, with no
- * Unicode normalisation. It throws `SEARCH_INVALID_FILTER` for `contains` or
- * `caseFold` on any other field, for a test text longer than 1,024 code points
- * on a pattern field, and for a `caseFold` test whose text has a case fold
- * longer than 2,048 code points.
+ * `startsWith`, and `endsWith` from the field's index of values. A `string` or
+ * `string[]` field whose type leaves out `pattern` keeps no index of whole
+ * values, so the engine throws `SEARCH_INVALID_FILTER` for those six tests,
+ * and for `matchesAny` and `containsAll`, on such a field.
+ *
+ * The engine also throws `SEARCH_INVALID_FILTER` in these cases:
+ *
+ * - The filter sets `contains`, `wildcard`, `regex`, or `caseFold` on a field
+ *   that is not a pattern field.
+ * - The text or the pattern of a test on a pattern field holds more than 1,024
+ *   code points.
+ * - A literal test under `caseFold` has a text whose case fold holds more than
+ *   2,048 code points.
+ * - A `wildcard` or `regex` pattern breaks its syntax or one of its limits.
  *
  * @public
  */
@@ -79,13 +89,84 @@ type StringFilter = Pick<ComparisonFilter, 'eq' | 'ne'> & {
     endsWith?: string;
     /** This matches a pattern field whose value holds the text anywhere in it. */
     contains?: string;
+    /**
+     * This matches a pattern field when the whole value matches the wildcard
+     * pattern. For example, `INV-*-2024` matches `INV-0042-2024`.
+     *
+     * In the pattern, `*` matches any sequence of code points, including an
+     * empty one, and `?` matches exactly one code point. Write `\` before a code
+     * point to match that code point itself, so `\*` matches an asterisk.
+     *
+     * The engine throws `SEARCH_INVALID_FILTER` for a pattern that ends in a
+     * `\` with no code point after it. It throws the same error for a pattern
+     * with more than 2,048 positions. Each `*`, each `?`, and each other code
+     * point counts as one position, except that under `caseFold` a code point
+     * counts once for each code point of its case fold.
+     */
+    wildcard?: string;
+    /**
+     * This matches a pattern field when some part of the value matches the
+     * regular expression. `^` and `$` match only at the start and at the end of
+     * the whole value.
+     *
+     * The engine accepts literal code points, `.`, `\d`, `\w`, and `\s`, sets
+     * such as `[a-z]` and `[^0-9]`, groups, and `|`. It also accepts the repeats
+     * `*`, `+`, `?`, `{n}`, `{n,}`, and `{n,m}`, the anchors `^` and `$`, the
+     * word edge `\b`, and number ranges such as `<1-65535>`. A number range
+     * matches the digits of any whole number from its low end to its high end.
+     * Write `\` before an ASCII punctuation mark to match the mark itself. The
+     * `.` matches any code point, including a line break.
+     *
+     * The matcher never backtracks, so it checks a value in at most as many
+     * steps as the value's code points multiplied by the pattern's positions.
+     *
+     * The engine throws `SEARCH_INVALID_FILTER` for any construct outside that
+     * syntax, such as a back-reference, a lookaround, a lazy repeat, or an inline
+     * flag. It throws the same error when the groups of a pattern nest more than
+     * 32 deep, when a count is above 2,048, and when a pattern holds more than
+     * 2,048 positions. When the operator of an HTTP server sets its `allowRegex`
+     * option to false, the server refuses every `regex` test.
+     */
+    regex?: string;
     /**
      * When this is true, the engine compares the case fold of each value of a
-     * pattern field with the case fold of the text, so a test for `error` matches
-     * `ERROR`. It applies to `eq`, `ne`, `in`, `nin`, `startsWith`, `endsWith`,
-     * and `contains`.
+     * pattern field with the case fold of the text, so a test for `error`
+     * matches `ERROR`. It applies to `eq`, `ne`, `in`, `nin`, `startsWith`,
+     * `endsWith`, `contains`, `wildcard`, and `regex`.
+     *
+     * Under `caseFold`, a set that does not open with `^` can also match a
+     * sequence of code points. When a member that the set holds on its own folds
+     * to several code points, the set matches that whole fold, so `[ß]` matches
+     * `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,8 +1,9 @@
-import { partialWordSearchModule } from './chunk-T5ZWEWVD.mjs';
-import './chunk-I23G3IZC.mjs';
-import './chunk-Z3DQPOJQ.mjs';
+import { partialWordSearchModule } from './chunk-PJU6EF22.mjs';
+import './chunk-NO3ABFLE.mjs';
+import './chunk-356UOTK2.mjs';
 import './chunk-KEHK2O6P.mjs';
-import './chunk-LJYTW7GT.mjs';
+import './chunk-GES7U2PM.mjs';
+import './chunk-IBR6634K.mjs';
 import './chunk-I64LXKO3.mjs';
 
 // src/partial-words/index.ts

package/dist/pattern.mjs

@@ -1,5 +1,6 @@
-import { patternSearchModule } from './chunk-XW25X6AU.mjs';
-import './chunk-ZKRV5M2P.mjs';
+import { patternSearchModule } from './chunk-4344I4MR.mjs';
+import './chunk-GES7U2PM.mjs';
+import './chunk-I64LXKO3.mjs';
 
 // src/pattern/index.ts
 var patternSearch = patternSearchModule;