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

package/dist/index.d.ts

@@ -1,12 +1,13 @@
-import { b as StopWordOverride, C as CustomTokenizer } from './schema-Bgzr4g7b.js';
-export { A as AnyDocument, B as BM25Params, E as EmbeddingFieldConfig, F as FieldOptionChain, c as FieldType, I as IndexConfig, a as InsertOptions, P as PartitionConfig, S as SchemaDefinition, d as ScoringMode, T as TextFieldOption, V as VectorIndexConfig, e as VectorQuantizationMode, f as VectorStorageMode, W as WriteOptions } from './schema-Bgzr4g7b.js';
+import { b as StopWordOverride, C as CustomTokenizer } from './schema-BBOCdhND.js';
+export { A as AnyDocument, B as BM25Params, E as EmbeddingFieldConfig, F as FieldOptionChain, c as FieldType, I as IndexConfig, a as InsertOptions, P as PartitionConfig, S as SchemaDefinition, d as ScoringMode, T as TextFieldOption, V as VectorIndexConfig, e as VectorQuantizationMode, f as VectorStorageMode, W as WriteOptions } from './schema-BBOCdhND.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, l as ComparisonFilter, D as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, m as FacetResult, n as FieldFilter, o as FilterExpression, G as GeoFilter, p as GeoPolygonFilter, q as GeoRadiusFilter, r as GroupConfig, s as GroupReducer, t as GroupResult, H as HighlightConfig, u as HighlightMatch, v as Hit, w as HybridConfig, I as IndexInfo, f as IndexStats, L as ListParams, g as ListResult, x as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, P as PartitionStatsResult, h as PreflightResult, y as PresenceFilter, z as ProcessMemoryReport, J as QueryCoverage, Q as QueryParams, e as QueryResult, K as ScoreComponents, O as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, R as SortField, T as SortSpec, U as StringFilter, j as SuggestParams, k as SuggestResult, W as TermMatchPolicy, V as VectorMaintenanceResult, X as VectorQueryConfig, Y as WorkerCopyReport, i as isNarsilError } from './memory-C7UMCMH3.js';
-import { N as NarsilConfig } from './config-Dfanyqqt.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-Dfanyqqt.js';
-import { a as Narsil } from './engine-igk0aMpQ.js';
-export { D as DocumentWriteOperations, I as IndexLifecycleOperations, N as NarsilEventMap } from './engine-igk0aMpQ.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-B4jMmygw.js';
+import { N as NarsilConfig } from './config-QXU3HMpq.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-QXU3HMpq.js';
+import { N as Narsil } from './engine-D_OzKZ-6.js';
+export { B as ByteSource, D as DocumentWriteOperations, I as IndexLifecycleOperations } from './engine-D_OzKZ-6.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';
 
@@ -81,6 +82,24 @@ declare function getTokenizer(name: string): CustomTokenizer;
  */
 declare function getStopWords(name: string): StopWordOverride;
 
+/**
+ * This makes pattern search available to every index whose schema declares a
+ * pattern field, meaning a `verbatim` field or a text field whose type
+ * includes `pattern`.
+ *
+ * A Node process needs no such call, because it loads the pattern search code
+ * by itself. A browser app has to import `patternSearch` from
+ * `@delali/narsil/pattern` and pass it to this function before it creates or
+ * loads an index with a pattern field.
+ *
+ * @param module - The `patternSearch` object that `@delali/narsil/pattern`
+ * exports.
+ * @throws A `NarsilError` with `CONFIG_INVALID` for any other object.
+ *
+ * @public
+ */
+declare function registerPatternSearch(module: PatternSearch): void;
+
 /**
  * Sets how many normalised tokens the engine keeps cached.
  *
@@ -178,4 +197,4 @@ declare function createNarsil(config?: NarsilConfig): Promise<Narsil>;
  */
 declare const VERSION = "0.1.0";
 
-export { CustomTokenizer, LanguageModule, Narsil, NarsilConfig, StopWordOverride, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerStopWords, registerTokenizer, resetNormalizationCache };
+export { CustomTokenizer, LanguageModule, Narsil, NarsilConfig, PatternSearch, StopWordOverride, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerPatternSearch, registerStopWords, registerTokenizer, resetNormalizationCache };

package/dist/index.mjs

@@ -1,19 +1,18 @@
-export { VERSION, createNarsil } from './chunk-IOR2K26O.mjs';
+export { VERSION, createNarsil } from './chunk-CVFAFZSN.mjs';
 import './chunk-GCM3JFVA.mjs';
-import './chunk-FVLQ63B7.mjs';
-export { getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerStopWords, registerTokenizer } from './chunk-M76V3OGJ.mjs';
-export { getLanguage, registerLanguage } from './chunk-HWQLTLNG.mjs';
-import './chunk-P4DSQ6M4.mjs';
-import './chunk-GIVAGD3Q.mjs';
-export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-LMO5TJUS.mjs';
-import './chunk-653BNMAF.mjs';
+import './chunk-AFKH4ZK3.mjs';
+export { getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerPatternSearch, registerStopWords, registerTokenizer } from './chunk-THMSFOJO.mjs';
+export { getLanguage, registerLanguage } from './chunk-4MQ5F4IL.mjs';
+import './chunk-ZULSEZCE.mjs';
+export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-3YKWSO54.mjs';
+import './chunk-AK3BLGCI.mjs';
 import './chunk-TGP5M5R7.mjs';
-export { isSimdAvailable } from './chunk-YJDQ7NLA.mjs';
+export { isSimdAvailable } from './chunk-WVDFG45M.mjs';
 import './chunk-ZJ4CSAB2.mjs';
-import './chunk-YNVIUGF5.mjs';
-import './chunk-3L4U6EJQ.mjs';
-import './chunk-IFBKLBGB.mjs';
+import './chunk-PU43WDY4.mjs';
+import './chunk-XW25X6AU.mjs';
+import './chunk-ZKRV5M2P.mjs';
 import './chunk-U2BKYEC7.mjs';
-import './chunk-OI42GWLR.mjs';
+import './chunk-LJYTW7GT.mjs';
 import './chunk-POWOTUKJ.mjs';
-export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-USKFU7J5.mjs';
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-I64LXKO3.mjs';

package/dist/invalidation/filesystem.mjs

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

package/dist/{memory-C7UMCMH3.d.ts → memory-B4jMmygw.d.ts}

@@ -1,4 +1,4 @@
-import { A as AnyDocument, S as SchemaDefinition, d as ScoringMode } from './schema-Bgzr4g7b.js';
+import { A as AnyDocument, S as SchemaDefinition, d as ScoringMode } from './schema-BBOCdhND.js';
 
 /**
  * Every code a {@link NarsilError} carries, grouped by the part of the engine
@@ -41,6 +41,7 @@ declare const ErrorCodes: {
     readonly SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE";
     readonly SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR";
     readonly SEARCH_RESULT_WINDOW_EXCEEDED: "SEARCH_RESULT_WINDOW_EXCEEDED";
+    readonly SEARCH_WORK_CAP_EXCEEDED: "SEARCH_WORK_CAP_EXCEEDED";
     readonly LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED";
     readonly ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH";
     readonly ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC";
@@ -81,7 +82,6 @@ declare const ErrorCodes: {
     readonly SNAPSHOT_SYNC_UNAUTHORIZED: "SNAPSHOT_SYNC_UNAUTHORIZED";
     readonly SNAPSHOT_SYNC_REQUEST_INVALID: "SNAPSHOT_SYNC_REQUEST_INVALID";
     readonly SNAPSHOT_SYNC_INDEX_NOT_FOUND: "SNAPSHOT_SYNC_INDEX_NOT_FOUND";
-    readonly SNAPSHOT_SYNC_TOO_LARGE: "SNAPSHOT_SYNC_TOO_LARGE";
     readonly SNAPSHOT_SYNC_CAPACITY_EXHAUSTED: "SNAPSHOT_SYNC_CAPACITY_EXHAUSTED";
     readonly SNAPSHOT_SYNC_SNAPSHOT_FAILED: "SNAPSHOT_SYNC_SNAPSHOT_FAILED";
     readonly SNAPSHOT_SYNC_DECODE_FAILED: "SNAPSHOT_SYNC_DECODE_FAILED";
@@ -225,6 +225,200 @@ declare class NarsilError extends Error {
  */
 declare function isNarsilError(value: unknown): value is NarsilError;
 
+/**
+ * This map lists every event that the engine emits, with the payload of each
+ * one.
+ *
+ * {@link Narsil.on} registers a listener under a key from this map, so that the
+ * engine can pass the matching payload to that listener. Most of these events
+ * report work that the engine does in the background, away from the call that
+ * started it, so a failure that such an event reports never rejects a promise
+ * that you are holding.
+ *
+ * @public
+ */
+type NarsilEventMap = {
+    /**
+     * The engine emits this event after a call changes what a read returns from
+     * an index. The calls are the inserts, updates, and removals, singly or in a
+     * batch, together with `clear`, `restore`, `rebalance`, `rebuildAnalysis`,
+     * `compactVectors`, `optimizeVectors`, `createIndex`, and `dropIndex`. The
+     * engine emits the event after a call that throws as well, because a call can
+     * change the index before it throws. It also emits the event after it reloads
+     * an index, once a shared invalidation adapter reports that another instance
+     * saved that index. The engine emits one event per batch, however many
+     * documents the batch holds.
+     *
+     * The engine emits the event once a query can see the change, which means
+     * after every worker copy applies the change and after any rebalance in
+     * progress replays it. A query that a listener sends from its handler
+     * therefore returns results that include the change. The engine waits for the
+     * change to become visible only while a listener is registered for the event.
+     */
+    write: {
+        /** This is the name of the index that changed. */
+        indexName: string;
+    };
+    /**
+     * A worker thread exited unexpectedly. The pool removes the thread and fails
+     * the requests that the thread was serving with `WORKER_CRASHED`. The engine
+     * then sends each of those queries again on the main thread, so the caller
+     * receives a result with no error. The remaining workers keep serving
+     * queries, because each of them holds a full worker copy of every promoted
+     * index.
+     *
+     * After a delay, the engine spawns a replacement and loads every copy onto
+     * it before it sends queries to the replacement. Once no worker is left, the
+     * main thread serves every query, because it holds every document. The first
+     * request after the delay then starts a new pool. The delay starts at one
+     * second and doubles up to a minute while replacements keep failing.
+     */
+    workerCrash: {
+        /** This is the id of the worker that exited. */
+        workerId: number;
+        /** These are the indexes that the worker held. */
+        indexNames: string[];
+        /** This is the error that ended the worker. */
+        error: Error;
+    };
+    /** An index gained worker copies, either because it reached the copy
+     * threshold or because a request loaded its copies again after an idle
+     * spell. */
+    workerPromote: {
+        /** This is the number of workers in the pool. */
+        workerCount: number;
+        /** This is the reason that the index gained its copies, such as the copy
+         * threshold that it reached. */
+        reason: string;
+    };
+    /** An index could not gain worker copies, so the main thread keeps serving
+     * its queries. */
+    workerPromoteFailure: {
+        /** This is the reason that the engine tried to load the copies. */
+        reason: string;
+        /** This is the error that stopped the load. */
+        error: Error;
+        /** This is true when the engine will try again at a later threshold. */
+        retryable: boolean;
+    };
+    /** An index finished spreading its documents across a new number of
+     * partitions. */
+    partitionRebalance: {
+        /** This is the name of the index that the engine rebalanced. */
+        indexName: string;
+        /** This is the number of partitions before the rebalance. */
+        oldCount: number;
+        /** This is the number of partitions after the rebalance. */
+        newCount: number;
+    };
+    /**
+     * An index passed its watermark, so its partitions are close to their
+     * capacity. On a cluster node, the engine reports the document count and the
+     * capacity of the one partition that `partitionId` identifies, which this
+     * node leads.
+     */
+    partitionWatermark: {
+        /** This is the name of the index that crossed the mark. */
+        indexName: string;
+        /** This is the number of documents in the index, or in the partition on a
+         * cluster node. */
+        documentCount: number;
+        /** This is the number of documents that the current partitions of the
+         * index can hold, or that the partition can hold on a cluster node. */
+        capacity: number;
+        /** This is the number of partitions in the index. */
+        partitionCount: number;
+        /** On a cluster node, this is the partition that crossed the mark, while
+         * outside a cluster the field is absent. */
+        partitionId?: number;
+    };
+    /**
+     * The process uses nine tenths of its heap, as measured during a write or a
+     * load, so the next large index can end the process with an out-of-memory
+     * error.
+     *
+     * Where `--max-old-space-size` or `--max-old-space-size-percentage` sets a
+     * limit, on the command line or in `NODE_OPTIONS`, the engine measures the
+     * used bytes against that limit, which `heapLimit` then reports. Where
+     * neither flag sets a limit, the engine measures the share of the heap that
+     * V8 reports as no longer available. V8 reports a limit about 192 MB above
+     * the true ceiling, so a process on a default heap below about 2 GB can end before
+     * this event fires.
+     *
+     * The engine emits the event once per crossing, then arms it again once the
+     * free share of the heap recovers to two tenths. Raise the limit with
+     * `--max-old-space-size-percentage` or `--max-old-space-size`, or close an
+     * idle index; see {@link ProcessMemoryReport.heapLimit}.
+     */
+    heapPressure: {
+        /** This is the index that a write or a load was touching when the heap
+         * reached that point. */
+        indexName: string;
+        /** This is the heap that the process uses, in bytes. */
+        heapUsed: number;
+        /** This is the size in bytes that the heap can grow to. */
+        heapLimit: number;
+        /** This is the estimate of the bytes that the index holds. */
+        estimatedMemoryBytes: number;
+    };
+    /** The engine started, completed, or failed a rebuild that brings the terms
+     * of an index up to the current analysis of its language module. */
+    analysisRebuild: {
+        /** This is the name of the index under rebuild. */
+        indexName: string;
+        /** This is the stage that the rebuild has reached. */
+        status: 'started' | 'completed' | 'failed';
+        /** This is the number of partitions that the rebuild has covered so far. */
+        partitionsRebuilt: number;
+        /** This is the number of partitions that the rebuild covers in total. */
+        partitionCount: number;
+        /** This is the error that stopped the rebuild, which only a `failed`
+         * status includes. */
+        error?: Error;
+    };
+    /** The engine started, completed, or failed the rewrite of an index that you
+     * saved with an earlier release. The engine rewrites the index as it
+     * recovers it, before it serves the index's first request. Because the
+     * engine writes the new manifest last, the earlier files stay intact through
+     * a failed rewrite. The engine then starts the rewrite again the next time
+     * it recovers the index. Without index lifecycle settings, the engine
+     * recovers every index before {@link createNarsil} returns, so pass the
+     * listener in the `events` setting of {@link createNarsil}. */
+    layoutUpgrade: {
+        /** This is the name of the index under rewrite. */
+        indexName: string;
+        /** This is the stage that the rewrite has reached. */
+        status: 'started' | 'completed' | 'failed';
+        /** This is `manifest` where the earlier index is a segment manifest with
+         * its files, and `bundle` where it is a single snapshot bundle. */
+        layout: 'manifest' | 'bundle';
+        /** This is the error that stopped the rewrite, which only a `failed`
+         * status includes. */
+        error?: Error;
+    };
+    /** A write to the write-ahead log or a checkpoint failed, so the writes since
+     * the last checkpoint are at risk. */
+    durabilityError: {
+        /** This is the error that the durability layer threw. */
+        error: Error;
+    };
+    /** The invalidation channel failed, so this instance can serve partitions
+     * that another instance has since changed. */
+    invalidationError: {
+        /** This is the error that the adapter threw. */
+        error: Error;
+    };
+};
+/**
+ * This map holds a listener for any event of {@link NarsilEventMap}, so that
+ * the engine can register each listener before it starts.
+ *
+ * @public
+ */
+type NarsilEventHandlers = {
+    [K in keyof NarsilEventMap]?: (payload: NarsilEventMap[K]) => void;
+};
+
 /**
  * What {@link Narsil.query} returns: the ranked hits and everything the query
  * asked for alongside them.
@@ -424,6 +618,24 @@ interface BatchResult {
         error: NarsilError;
     }>;
 }
+/**
+ * What {@link Narsil.importDocumentExport} returns. The engine continues past each
+ * refused line, so read the refusals to learn which documents it skipped.
+ *
+ * @public
+ */
+interface DocumentImportResult {
+    /** The engine wrote this many documents, counting each one that it replaced. */
+    imported: number;
+    /** The engine refused this many lines in total. */
+    refusedCount: number;
+    /** These are the 1,000 refusals with the lowest line numbers. Each entry contains the line number, where the header is line 1, along with the error code and a message. */
+    refused: Array<{
+        line: number;
+        code: NarsilErrorCode;
+        message: string;
+    }>;
+}
 /**
  * What {@link Narsil.getStats} returns about one index.
  *
@@ -577,9 +789,13 @@ interface ListResult<T = AnyDocument> {
  * @public
  */
 type ComparisonFilter = {
-    /** This matches a field equal to the value. */
+    /** This matches a field equal to the value, or a list field where one element equals it. */
     eq?: number | string | boolean;
-    /** This matches a field holding anything other than the value. */
+    /**
+     * This matches a document that holds the field with a value other than this
+     * one, or a list field where every element differs from it, which an empty
+     * list does.
+     */
     ne?: number | string | boolean;
     /** This matches a field greater than the number. */
     gt?: number;
@@ -596,10 +812,10 @@ type ComparisonFilter = {
  * The engine tests a text field against this filter for equality, for a text
  * range, or with the set and prefix tests.
  *
- * The engine compares each element of a `string[]` or `verbatim[]` field, so
- * it matches a document with `eq`, `in`, `startsWith`, or `endsWith` where
- * one element passes the test, while it matches a document with `ne` or `nin`
- * where every element differs from the values.
+ * 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.
  *
  * The engine applies the range tests `gt`, `gte`, `lt`, `lte`, and `between`
  * to a single `string` or `verbatim` field whose type includes `sortable`,
@@ -607,6 +823,21 @@ type ComparisonFilter = {
  * 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.
  *
+ * 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.
+ * 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.
+ *
  * @public
  */
 type StringFilter = Pick<ComparisonFilter, 'eq' | 'ne'> & {
@@ -620,26 +851,41 @@ type StringFilter = Pick<ComparisonFilter, 'eq' | 'ne'> & {
     lte?: string;
     /** This matches a value inside the inclusive range in sort order, given as `[low, high]`. */
     between?: [string, string];
-    /** This matches a field equal to any value in the list. */
+    /** This matches a field equal to any value in the list, which holds at most 65,536 values. */
     in?: string[];
-    /** This matches a field that differs from every value in the list. */
+    /** This matches a field that differs from every value in the list, which holds at most 65,536 values. */
     nin?: string[];
     /** This matches a field starting with the text. */
     startsWith?: string;
     /** This matches a field ending with the text. */
     endsWith?: string;
+    /** This matches a pattern field whose value holds the text anywhere in it. */
+    contains?: 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`.
+     */
+    caseFold?: boolean;
 };
 /**
- * Tests the contents of an array field.
+ * Tests the contents of a list field, which is a `number[]`, `boolean[]`,
+ * `enum[]`, `verbatim[]`, or `string[]` field.
+ *
+ * The engine throws `SEARCH_INVALID_FILTER` for these tests on any other
+ * field, for a value whose type differs from the type of the list's elements,
+ * and for `containsAll` or `matchesAny` on a `string[]` field whose type leaves
+ * out `pattern`.
  *
  * @public
  */
 type ArrayFilter = {
-    /** This matches an array holding every one of the values. */
+    /** This matches a list holding every one of the values, at most 65,536 of them, so an empty set of values matches every list. */
     containsAll?: (string | number | boolean)[];
-    /** This matches an array holding at least one of the values. */
+    /** This matches a list holding at least one of the values, at most 65,536 of them. */
     matchesAny?: (string | number | boolean)[];
-    /** This compares the array's length. */
+    /** This compares the number of elements in the list. */
     size?: ComparisonFilter;
 };
 /**
@@ -649,13 +895,13 @@ type ArrayFilter = {
  * @public
  */
 type PresenceFilter = {
-    /** This matches a document where the field is present. */
+    /** This matches a document where the field holds a value other than null. */
     exists?: boolean;
-    /** This matches a document where the field is absent. */
+    /** This matches a document where the field is absent or null. */
     notExists?: boolean;
-    /** This matches an empty string or an empty array. */
+    /** This matches a document where the field is absent, null, an empty string, or an empty list. */
     isEmpty?: boolean;
-    /** This matches a string or array holding something. */
+    /** This matches a document where the field holds a value other than an empty string or an empty list. */
     isNotEmpty?: boolean;
 };
 /**
@@ -666,9 +912,9 @@ type PresenceFilter = {
 type GeoRadiusFilter = {
     /** The engine tests the field against this circle. */
     radius: {
-        /** The centre has this latitude, in degrees. */
+        /** The centre has this latitude, in degrees from -90 to 90. For any other value, the engine throws `SEARCH_INVALID_FILTER`. */
         lat: number;
-        /** The centre has this longitude, in degrees. */
+        /** The centre has this longitude, in degrees from -180 to 180. For any other value, the engine throws `SEARCH_INVALID_FILTER`. */
         lon: number;
         /** The circle has this radius, measured in `unit`. */
         distance: number;
@@ -701,9 +947,11 @@ type GeoPolygonFilter = {
         /**
          * The engine closes the ring through these corners in the order that you
          * list them, so you can leave the first point off the end. It throws
-         * `SEARCH_INVALID_FILTER` for a ring of fewer than three corners, since
-         * such a ring encloses no area. List the corners counter-clockwise around
-         * the area, as in an exterior ring of GeoJSON. Where the corners
+         * `SEARCH_INVALID_FILTER` for a ring of fewer than three corners, which
+         * encloses no area, and for a corner whose latitude is outside -90 to 90
+         * or whose longitude is outside -180 to 180. It also throws that error for
+         * a ring of more than 65,536 corners. List the corners counter-clockwise
+         * around the area, as in an exterior ring of GeoJSON. Where the corners
          * span 180 degrees of longitude or more, the engine matches the area on
          * the left of that path, so a ring listed that way can cross the
          * antimeridian or span more than half the globe.
@@ -730,11 +978,15 @@ type GeoFilter = GeoRadiusFilter | GeoPolygonFilter;
  */
 type FieldFilter = ComparisonFilter | StringFilter | ArrayFilter | PresenceFilter | GeoFilter;
 /**
- * The filter a query runs, built from per-field tests and the boolean
+ * The filter that a query runs, built from per-field tests and the boolean
  * operators that combine them.
  *
- * Nest the operators to whatever depth the query needs. The engine applies the
- * filter before scoring, so a narrow filter makes a search cheaper.
+ * The engine answers every test from an index that it keeps for the field. It
+ * applies the filter before scoring, so a narrow filter makes a search
+ * cheaper. A filter nests at most 30 levels deep and holds at most 1,024
+ * tests, counted across every field and nested expression. Past either limit,
+ * the engine throws `SEARCH_INVALID_FILTER`, while it throws
+ * `SEARCH_INVALID_FIELD` for a test on a field that the schema leaves out.
  *
  * @public
  */
@@ -1252,4 +1504,4 @@ interface MemoryStats {
     }>;
 }
 
-export { type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentProjection as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type QueryCoverage as J, type ScoreComponents as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type SearchMode as O, type PartitionStatsResult as P, type QueryParams as Q, type SortField as R, type ServerErrorCode as S, type SortSpec as T, type StringFilter as U, type VectorMaintenanceResult as V, type TermMatchPolicy as W, type VectorQueryConfig as X, type WorkerCopyReport as Y, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type IndexStats as f, type ListResult as g, type PreflightResult as h, isNarsilError as i, type SuggestParams as j, type SuggestResult as k, type ComparisonFilter as l, type FacetResult as m, type FieldFilter as n, type FilterExpression as o, type GeoPolygonFilter as p, type GeoRadiusFilter as q, type GroupConfig as r, type GroupReducer as s, type GroupResult as t, type HighlightMatch as u, type Hit as v, type HybridConfig as w, type ListedDocument as x, type PresenceFilter as y, type ProcessMemoryReport as z };
+export { type WorkerCopyReport as $, type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentImportResult as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type ListedDocument as J, type PresenceFilter as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type ProcessMemoryReport as O, type PartitionStatsResult as P, type QueryParams as Q, type QueryCoverage as R, type ServerErrorCode as S, type ScoreComponents as T, type SearchMode as U, type VectorMaintenanceResult as V, type SortField as W, type SortSpec as X, type StringFilter as Y, type TermMatchPolicy as Z, type VectorQueryConfig as _, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type NarsilEventHandlers as f, type IndexStats as g, type ListResult as h, isNarsilError as i, type PreflightResult as j, type SuggestParams as k, type SuggestResult as l, type NarsilEventMap as m, type ComparisonFilter as n, type DocumentProjection as o, type FacetResult as p, type FieldFilter as q, type FilterExpression as r, type GeoPolygonFilter as s, type GeoRadiusFilter as t, type GroupConfig as u, type GroupReducer as v, type GroupResult as w, type HighlightMatch as x, type Hit as y, type HybridConfig as z };

package/dist/pattern-Cledccbl.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This object holds the code with which the engine builds the pattern index of
+ * each pattern field and answers `contains` and the other text tests on that
+ * field.
+ *
+ * A Node process loads this code by itself. A browser bundle includes it only
+ * where the app imports `patternSearch` from `@delali/narsil/pattern` and
+ * passes it to {@link registerPatternSearch}, so a bundler can leave it out of
+ * an app that has no pattern field.
+ *
+ * @public
+ */
+interface PatternSearch {
+    /** This is always `'pattern'`, the name of the code that the object holds. */
+    readonly name: 'pattern';
+}
+
+export type { PatternSearch as P };

package/dist/pattern.d.ts

@@ -0,0 +1,22 @@
+import { P as PatternSearch } from './pattern-Cledccbl.js';
+
+/**
+ * This object holds the pattern search code, which a browser app has to pass
+ * to {@link registerPatternSearch} before it creates or loads an index with a
+ * pattern field.
+ *
+ * ```ts
+ * import { registerPatternSearch } from '@delali/narsil'
+ * import { patternSearch } from '@delali/narsil/pattern'
+ *
+ * registerPatternSearch(patternSearch)
+ * ```
+ *
+ * A Node process loads the pattern search code by itself, so it needs no such
+ * call.
+ *
+ * @public
+ */
+declare const patternSearch: PatternSearch;
+
+export { PatternSearch, patternSearch };

package/dist/pattern.mjs

@@ -0,0 +1,7 @@
+import { patternSearchModule } from './chunk-XW25X6AU.mjs';
+import './chunk-ZKRV5M2P.mjs';
+
+// src/pattern/index.ts
+var patternSearch = patternSearchModule;
+
+export { patternSearch };