@topgunbuild/core 0.8.0 → 0.9.0

package/dist/index.d.mts

@@ -1161,12 +1161,35 @@ declare function serialize(data: unknown): Uint8Array;
  */
 declare function deserialize<T = unknown>(data: Uint8Array | ArrayBuffer): T;
 
-type PredicateOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'regex' | 'contains' | 'containsAll' | 'containsAny' | 'and' | 'or' | 'not';
+type PredicateOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'regex' | 'contains' | 'containsAll' | 'containsAny' | 'and' | 'or' | 'not' | 'match' | 'matchPhrase' | 'matchPrefix';
+/**
+ * Options for full-text search match predicate.
+ */
+interface MatchOptions {
+    /** Minimum BM25 score threshold */
+    minScore?: number;
+    /** Boost factor for this field */
+    boost?: number;
+    /** Operator for multi-term queries: 'and' requires all terms, 'or' requires any */
+    operator?: 'and' | 'or';
+    /** Fuzziness level for typo tolerance (0 = exact, 1 = 1 edit, 2 = 2 edits) */
+    fuzziness?: number;
+}
 interface PredicateNode {
     op: PredicateOp;
     attribute?: string;
     value?: any;
     children?: PredicateNode[];
+    /** FTS-specific: search query string */
+    query?: string;
+    /** FTS-specific: match options */
+    matchOptions?: MatchOptions;
+    /** FTS-specific: phrase slop (word distance tolerance) */
+    slop?: number;
+    /** FTS-specific: prefix for matchPrefix */
+    prefix?: string;
+    /** FTS-specific: max prefix expansions */
+    maxExpansions?: number;
 }
 declare class Predicates {
     static equal(attribute: string, value: any): PredicateNode;
@@ -1205,6 +1228,82 @@ declare class Predicates {
      * @param values - Text values, any of which can match
      */
     static containsAny(attribute: string, values: string[]): PredicateNode;
+    /**
+     * Create a 'match' predicate for full-text search.
+     * Uses BM25 scoring to find relevant documents.
+     *
+     * @param attribute - Field to search in
+     * @param query - Search query string
+     * @param options - Match options (minScore, boost, operator, fuzziness)
+     *
+     * @example
+     * ```typescript
+     * // Simple match
+     * Predicates.match('title', 'machine learning')
+     *
+     * // With options
+     * Predicates.match('body', 'neural networks', { minScore: 1.0, boost: 2.0 })
+     * ```
+     */
+    static match(attribute: string, query: string, options?: MatchOptions): PredicateNode;
+    /**
+     * Create a 'matchPhrase' predicate for exact phrase matching.
+     * Matches documents containing the exact phrase (words in order).
+     *
+     * @param attribute - Field to search in
+     * @param query - Phrase to match
+     * @param slop - Word distance tolerance (0 = exact, 1 = allow 1 word between)
+     *
+     * @example
+     * ```typescript
+     * // Exact phrase
+     * Predicates.matchPhrase('body', 'machine learning')
+     *
+     * // With slop (allows "machine deep learning")
+     * Predicates.matchPhrase('body', 'machine learning', 1)
+     * ```
+     */
+    static matchPhrase(attribute: string, query: string, slop?: number): PredicateNode;
+    /**
+     * Create a 'matchPrefix' predicate for prefix matching.
+     * Matches documents where field starts with the given prefix.
+     *
+     * @param attribute - Field to search in
+     * @param prefix - Prefix to match
+     * @param maxExpansions - Maximum number of term expansions
+     *
+     * @example
+     * ```typescript
+     * // Match titles starting with "mach"
+     * Predicates.matchPrefix('title', 'mach')
+     *
+     * // Limit expansions for performance
+     * Predicates.matchPrefix('title', 'mach', 50)
+     * ```
+     */
+    static matchPrefix(attribute: string, prefix: string, maxExpansions?: number): PredicateNode;
+    /**
+     * Create a multi-field match predicate.
+     * Searches across multiple fields with optional per-field boosting.
+     *
+     * @param attributes - Fields to search in
+     * @param query - Search query string
+     * @param options - Options including per-field boost factors
+     *
+     * @example
+     * ```typescript
+     * // Search title and body
+     * Predicates.multiMatch(['title', 'body'], 'machine learning')
+     *
+     * // With boosting (title 2x more important)
+     * Predicates.multiMatch(['title', 'body'], 'machine learning', {
+     *   boost: { title: 2.0, body: 1.0 }
+     * })
+     * ```
+     */
+    static multiMatch(attributes: string[], query: string, options?: {
+        boost?: Record<string, number>;
+    }): PredicateNode;
 }
 declare function evaluatePredicate(predicate: PredicateNode, data: any): boolean;
 
@@ -3767,6 +3866,52 @@ interface SimpleQueryNode extends QueryNode {
     /** For 'between' queries: include upper bound (default: false) */
     toInclusive?: boolean;
 }
+/**
+ * Options for full-text search match queries.
+ */
+interface MatchQueryOptions {
+    /** Minimum BM25 score threshold */
+    minScore?: number;
+    /** Boost factor for this field */
+    boost?: number;
+    /** Operator for multi-term queries: 'and' requires all terms, 'or' requires any */
+    operator?: 'and' | 'or';
+    /** Fuzziness level for typo tolerance (0 = exact, 1 = 1 edit, 2 = 2 edits) */
+    fuzziness?: number;
+}
+/**
+ * Match query node for BM25 full-text search.
+ */
+interface MatchQueryNode extends QueryNode {
+    type: 'match';
+    attribute: string;
+    query: string;
+    options?: MatchQueryOptions;
+}
+/**
+ * Match phrase query node for exact phrase matching.
+ */
+interface MatchPhraseQueryNode extends QueryNode {
+    type: 'matchPhrase';
+    attribute: string;
+    query: string;
+    /** Word distance tolerance (0 = exact phrase) */
+    slop?: number;
+}
+/**
+ * Match prefix query node for prefix matching.
+ */
+interface MatchPrefixQueryNode extends QueryNode {
+    type: 'matchPrefix';
+    attribute: string;
+    prefix: string;
+    /** Maximum number of term expansions */
+    maxExpansions?: number;
+}
+/**
+ * Union type for FTS query nodes.
+ */
+type FTSQueryNode = MatchQueryNode | MatchPhraseQueryNode | MatchPrefixQueryNode;
 /**
  * Logical query node for combining conditions.
  */
@@ -3778,7 +3923,7 @@ interface LogicalQueryNode {
 /**
  * Union type for all query types.
  */
-type Query = SimpleQueryNode | LogicalQueryNode;
+type Query = SimpleQueryNode | LogicalQueryNode | FTSQueryNode;
 /**
  * Query execution options for sort/limit/offset.
  */
@@ -3794,7 +3939,7 @@ interface QueryOptions {
  * Execution plan step.
  * Represents a single operation in the query execution plan.
  */
-type PlanStep = IndexScanStep | FullScanStep | IntersectionStep | UnionStep | FilterStep | NotStep;
+type PlanStep = IndexScanStep | FullScanStep | IntersectionStep | UnionStep | FilterStep | NotStep | FTSScanStep | FusionStep;
 /**
  * Index scan step - retrieves from an index.
  */
@@ -3840,6 +3985,41 @@ interface NotStep {
     source: PlanStep;
     allKeys: () => Set<unknown>;
 }
+/**
+ * Fusion strategy for combining results from different search methods.
+ */
+type FusionStrategy = 'intersection' | 'rrf' | 'score-filter';
+/**
+ * FTS scan step - full-text search using FullTextIndex.
+ * Returns scored results (documents with BM25 scores).
+ */
+interface FTSScanStep {
+    type: 'fts-scan';
+    /** Field to search */
+    field: string;
+    /** Search query or phrase */
+    query: string;
+    /** Type of FTS query */
+    ftsType: 'match' | 'matchPhrase' | 'matchPrefix';
+    /** Query options (minScore, boost, etc.) */
+    options?: MatchQueryOptions;
+    /** This step returns scored results */
+    returnsScored: true;
+    /** Estimated cost */
+    estimatedCost: number;
+}
+/**
+ * Fusion step - combines results from multiple steps using RRF or other strategy.
+ */
+interface FusionStep {
+    type: 'fusion';
+    /** Steps to combine */
+    steps: PlanStep[];
+    /** Fusion strategy */
+    strategy: FusionStrategy;
+    /** Whether result is scored (true if any child is scored) */
+    returnsScored: boolean;
+}
 /**
  * Complete query execution plan.
  */
@@ -4939,160 +5119,764 @@ declare class LazyInvertedIndex<K, V, A extends string = string> implements Lazy
 }
 
 /**
- * SetResultSet Implementation
- *
- * ResultSet backed by a Set, used for HashIndex results.
- *
- * @module query/resultset/SetResultSet
- */
-
-/**
- * ResultSet backed by a Set.
- * Provides O(1) contains() check and direct iteration.
- */
-declare class SetResultSet<K> implements ResultSet<K> {
-    private readonly keys;
-    private readonly retrievalCost;
-    constructor(keys: Set<K>, retrievalCost: number);
-    [Symbol.iterator](): Iterator<K>;
-    getRetrievalCost(): number;
-    getMergeCost(): number;
-    contains(key: K): boolean;
-    size(): number;
-    toArray(): K[];
-    isEmpty(): boolean;
-}
-
-/**
- * LazyResultSet Implementation
+ * Full-Text Search Types
  *
- * Lazily evaluated result set for range queries.
- * Used when materializing all results upfront would be expensive.
+ * Type definitions for the FTS (Full-Text Search) module.
+ * This module provides BM25-based keyword search capabilities.
  *
- * @module query/resultset/LazyResultSet
- */
-
-/**
- * Factory function type that creates a generator for lazy iteration.
+ * @module fts/types
  */
-type IteratorFactory<K> = () => Generator<K>;
 /**
- * Lazily evaluated result set.
- * Used for range queries where materializing all results upfront is expensive.
- *
- * K = record key type
+ * Options for configuring the FTS Tokenizer.
  */
-declare class LazyResultSet<K> implements ResultSet<K> {
-    private readonly iteratorFactory;
-    private readonly retrievalCost;
-    private readonly estimatedSize;
-    /** Cached materialized results */
-    private cached;
+interface TokenizerOptions {
     /**
-     * Create a LazyResultSet.
-     *
-     * @param iteratorFactory - Factory that creates a fresh generator each time
-     * @param retrievalCost - Cost of retrieving results from the index
-     * @param estimatedSize - Estimated result count for merge cost calculation
+     * Convert all text to lowercase before tokenization.
+     * @default true
      */
-    constructor(iteratorFactory: IteratorFactory<K>, retrievalCost: number, estimatedSize: number);
-    [Symbol.iterator](): Generator<K>;
-    getRetrievalCost(): number;
-    getMergeCost(): number;
-    contains(key: K): boolean;
-    size(): number;
-    toArray(): K[];
-    isEmpty(): boolean;
+    lowercase?: boolean;
     /**
-     * Check if the result set has been materialized.
-     * Useful for testing lazy evaluation behavior.
+     * Set of words to exclude from tokenization (e.g., "the", "and", "is").
+     * @default ENGLISH_STOPWORDS (174 words)
      */
-    isMaterialized(): boolean;
+    stopwords?: Set<string>;
     /**
-     * Force materialization of the result set.
-     * Returns the cached array.
+     * Function to reduce words to their root form.
+     * @default Porter stemmer
      */
-    materialize(): K[];
+    stemmer?: (word: string) => string;
     /**
-     * Get the estimated size before materialization.
+     * Minimum token length to include in results.
+     * @default 2
      */
-    getEstimatedSize(): number;
+    minLength?: number;
+    /**
+     * Maximum token length to include in results.
+     * @default 40
+     */
+    maxLength?: number;
 }
-
 /**
- * IntersectionResultSet Implementation
- *
- * Intersection of multiple result sets (AND logic).
- * Implements CQEngine "smallest first" strategy:
- * iterate the smallest set, check membership in others.
- *
- * @module query/resultset/IntersectionResultSet
+ * Information about a term's occurrence in a document.
  */
-
+interface TermInfo {
+    /** Document ID where the term appears */
+    docId: string;
+    /** Number of times the term appears in the document */
+    termFrequency: number;
+    /** Optional: positions of the term for phrase search (future) */
+    fieldPositions?: number[];
+}
 /**
- * Intersection of multiple result sets (AND logic).
- * CQEngine strategy: iterate smallest set, check membership in others.
- *
- * K = record key type
+ * Posting list entry for the inverted index.
  */
-declare class IntersectionResultSet<K> implements ResultSet<K> {
-    /** Cached materialized results */
-    private cached;
-    /** Result sets sorted by merge cost */
-    private sortedResultSets;
-    /**
-     * Create an IntersectionResultSet.
-     *
-     * @param resultSets - Result sets to intersect
-     */
-    constructor(resultSets: ResultSet<K>[]);
-    /**
-     * Lazy iteration over intersection.
-     * Iterates smallest set, yields only keys present in all sets.
-     */
-    [Symbol.iterator](): Generator<K>;
-    /**
-     * Retrieval cost is minimum of all (we only iterate smallest).
-     */
-    getRetrievalCost(): number;
-    /**
-     * Merge cost is estimated as smallest set size (upper bound).
-     */
-    getMergeCost(): number;
-    /**
-     * Check if key is in all result sets.
-     */
-    contains(key: K): boolean;
-    /**
-     * Get size by materializing results.
-     */
-    size(): number;
-    /**
-     * Materialize to array with caching.
-     */
-    toArray(): K[];
+interface Posting {
+    /** Document ID */
+    docId: string;
+    /** Term frequency in this document */
+    termFrequency: number;
+    /** Optional: positions for phrase search */
+    positions?: number[];
+}
+/**
+ * BM25 algorithm configuration options.
+ */
+interface BM25Options {
     /**
-     * Check if empty (tries to avoid full materialization).
+     * Term frequency saturation parameter.
+     * Higher values give more weight to repeated terms.
+     * @default 1.2
      */
-    isEmpty(): boolean;
+    k1?: number;
     /**
-     * Check if results have been materialized.
+     * Document length normalization parameter.
+     * 0 = no length normalization, 1 = full normalization.
+     * @default 0.75
      */
-    isMaterialized(): boolean;
+    b?: number;
 }
-
 /**
- * UnionResultSet Implementation
- *
- * Union of multiple result sets (OR logic).
- * Deduplicates results using a Set during iteration.
- *
- * @module query/resultset/UnionResultSet
+ * A document with its BM25 relevance score.
  */
-
+interface ScoredDocument {
+    /** Document ID */
+    docId: string;
+    /** BM25 relevance score */
+    score: number;
+    /** Terms from the query that matched this document */
+    matchedTerms: string[];
+}
 /**
- * Union of multiple result sets (OR logic).
- * Deduplicates results.
+ * Configuration for a FullTextIndex.
+ */
+interface FullTextIndexConfig {
+    /** Fields to index for full-text search (e.g., ['title', 'body']) */
+    fields: string[];
+    /** Tokenizer configuration */
+    tokenizer?: TokenizerOptions;
+    /** BM25 scoring parameters */
+    bm25?: BM25Options;
+}
+/**
+ * Options for search queries.
+ */
+interface SearchOptions {
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Minimum BM25 score threshold */
+    minScore?: number;
+    /** Restrict search to specific fields */
+    fields?: string[];
+    /** Field boost weights (e.g., { title: 2.0, body: 1.0 }) */
+    boost?: Record<string, number>;
+}
+/**
+ * Search result with full details.
+ */
+interface SearchResult {
+    /** Document ID */
+    docId: string;
+    /** BM25 relevance score */
+    score: number;
+    /** Source of the match (for hybrid search) */
+    source?: 'exact' | 'fulltext' | 'vector' | 'bfs';
+    /** Original document data (if requested) */
+    data?: unknown;
+    /** Highlighted text snippet (if requested) */
+    highlightedText?: string;
+    /** Terms that matched */
+    matchedTerms?: string[];
+    /** Document embedding (if available) */
+    embedding?: number[];
+    /** Cosine similarity to query (0-1) */
+    embeddingSimilarity?: number;
+    /** Debug information */
+    debug?: {
+        exactScore?: number;
+        fulltextScore?: number;
+        vectorScore?: number;
+        rangeScore?: number;
+    };
+}
+/**
+ * Serialized format for index persistence.
+ */
+interface SerializedIndex {
+    /** Schema version for backwards compatibility */
+    version: number;
+    /** Index metadata */
+    metadata: {
+        totalDocs: number;
+        avgDocLength: number;
+        createdAt: number;
+        lastModified: number;
+    };
+    /** Serialized term data */
+    terms: Array<{
+        term: string;
+        idf: number;
+        postings: Array<{
+            docId: string;
+            termFrequency: number;
+            positions?: number[];
+        }>;
+    }>;
+    /** Document lengths for BM25 normalization */
+    docLengths: Record<string, number>;
+}
+
+/**
+ * English stopwords list (174 common words).
+ * These words are filtered out during tokenization as they
+ * don't contribute to search relevance.
+ */
+declare const ENGLISH_STOPWORDS: Set<string>;
+
+/**
+ * Porter Stemming Algorithm
+ *
+ * Reduces English words to their stem (root form).
+ * Based on the algorithm by Martin Porter (1980).
+ *
+ * @see https://tartarus.org/martin/PorterStemmer/
+ *
+ * @param word - Word to stem (should be lowercase)
+ * @returns Stemmed word
+ */
+declare function porterStem(word: string): string;
+
+/**
+ * FTS Tokenizer with Porter Stemming and Stopwords
+ *
+ * Provides text tokenization for BM25 full-text search.
+ * Features:
+ * - Unicode-aware word boundary detection
+ * - English stopwords filtering (174 words)
+ * - Porter stemming algorithm for word normalization
+ * - Configurable min/max token length
+ *
+ * @module fts/Tokenizer
+ */
+
+/**
+ * FTS Tokenizer
+ *
+ * Splits text into searchable tokens with normalization.
+ *
+ * @example
+ * ```typescript
+ * const tokenizer = new BM25Tokenizer();
+ * const tokens = tokenizer.tokenize('The quick brown foxes');
+ * // ['quick', 'brown', 'fox']
+ * ```
+ */
+declare class BM25Tokenizer implements Tokenizer {
+    private readonly options;
+    /**
+     * Create a new BM25Tokenizer.
+     *
+     * @param options - Configuration options
+     */
+    constructor(options?: TokenizerOptions);
+    /**
+     * Tokenize text into an array of normalized tokens.
+     *
+     * @param text - Text to tokenize
+     * @returns Array of tokens
+     */
+    tokenize(text: string): string[];
+}
+
+/**
+ * FTS Inverted Index
+ *
+ * Data structure for full-text search that maps terms to documents.
+ * Supports efficient term lookup, document frequency calculation,
+ * and IDF (Inverse Document Frequency) for BM25 scoring.
+ *
+ * @module fts/BM25InvertedIndex
+ */
+
+/**
+ * Inverted Index for Full-Text Search (BM25)
+ *
+ * Maps terms to the documents containing them, along with term frequency
+ * information needed for BM25 scoring.
+ *
+ * @example
+ * ```typescript
+ * const index = new BM25InvertedIndex();
+ * index.addDocument('doc1', ['hello', 'world']);
+ * index.addDocument('doc2', ['hello', 'there']);
+ *
+ * const docs = index.getDocumentsForTerm('hello');
+ * // [{ docId: 'doc1', termFrequency: 1 }, { docId: 'doc2', termFrequency: 1 }]
+ * ```
+ */
+declare class BM25InvertedIndex {
+    /** term → list of documents containing term */
+    private index;
+    /** document → total term count (for length normalization) */
+    private docLengths;
+    /** document → set of terms (for efficient removal) */
+    private docTerms;
+    /** Inverse Document Frequency cache */
+    private idfCache;
+    /** Total number of documents */
+    private totalDocs;
+    /** Average document length */
+    private avgDocLength;
+    constructor();
+    /**
+     * Add a document to the index.
+     *
+     * @param docId - Unique document identifier
+     * @param tokens - Array of tokens (already tokenized/stemmed)
+     */
+    addDocument(docId: string, tokens: string[]): void;
+    /**
+     * Remove a document from the index.
+     *
+     * @param docId - Document identifier to remove
+     */
+    removeDocument(docId: string): void;
+    /**
+     * Get all documents containing a term.
+     *
+     * @param term - Term to look up
+     * @returns Array of TermInfo objects
+     */
+    getDocumentsForTerm(term: string): TermInfo[];
+    /**
+     * Calculate IDF (Inverse Document Frequency) for a term.
+     *
+     * Uses BM25 IDF formula:
+     * IDF = log((N - df + 0.5) / (df + 0.5) + 1)
+     *
+     * Where:
+     * - N = total documents
+     * - df = document frequency (docs containing term)
+     *
+     * @param term - Term to calculate IDF for
+     * @returns IDF value (0 if term doesn't exist)
+     */
+    getIDF(term: string): number;
+    /**
+     * Get the length of a document (number of tokens).
+     *
+     * @param docId - Document identifier
+     * @returns Document length (0 if not found)
+     */
+    getDocLength(docId: string): number;
+    /**
+     * Get the average document length.
+     *
+     * @returns Average length across all documents
+     */
+    getAvgDocLength(): number;
+    /**
+     * Get the total number of documents in the index.
+     *
+     * @returns Total document count
+     */
+    getTotalDocs(): number;
+    /**
+     * Get iterator for document lengths (useful for serialization).
+     *
+     * @returns Iterator of [docId, length] pairs
+     */
+    getDocLengths(): IterableIterator<[string, number]>;
+    /**
+     * Get the number of documents in the index (alias for getTotalDocs).
+     *
+     * @returns Number of indexed documents
+     */
+    getSize(): number;
+    /**
+     * Clear all data from the index.
+     */
+    clear(): void;
+    /**
+     * Check if a document exists in the index.
+     *
+     * @param docId - Document identifier
+     * @returns True if document exists
+     */
+    hasDocument(docId: string): boolean;
+    /**
+     * Get all unique terms in the index.
+     *
+     * @returns Iterator of all terms
+     */
+    getTerms(): IterableIterator<string>;
+    /**
+     * Get the number of unique terms in the index.
+     *
+     * @returns Number of unique terms
+     */
+    getTermCount(): number;
+    /**
+     * Update the average document length after add/remove.
+     */
+    private updateAvgDocLength;
+}
+
+/**
+ * BM25 Scorer
+ *
+ * Implements the Okapi BM25 ranking algorithm for full-text search.
+ * BM25 is a probabilistic relevance ranking function used to estimate
+ * the relevance of documents to a given search query.
+ *
+ * @see https://en.wikipedia.org/wiki/Okapi_BM25
+ * @module fts/BM25Scorer
+ */
+
+/**
+ * BM25 Scorer for relevance ranking
+ *
+ * The BM25 formula:
+ * score(D,Q) = Σ IDF(qi) × (f(qi,D) × (k1 + 1)) / (f(qi,D) + k1 × (1 - b + b × |D| / avgdl))
+ *
+ * Where:
+ * - D = document
+ * - Q = query
+ * - qi = query term i
+ * - f(qi,D) = term frequency of qi in D
+ * - |D| = length of D (number of terms)
+ * - avgdl = average document length
+ * - k1 = term frequency saturation parameter (default: 1.2)
+ * - b = document length normalization parameter (default: 0.75)
+ *
+ * @example
+ * ```typescript
+ * const index = new BM25InvertedIndex();
+ * index.addDocument('doc1', ['hello', 'world']);
+ * index.addDocument('doc2', ['hello', 'there']);
+ *
+ * const scorer = new BM25Scorer();
+ * const results = scorer.score(['hello'], index);
+ * // [{ docId: 'doc1', score: 0.28, matchedTerms: ['hello'] }, ...]
+ * ```
+ */
+declare class BM25Scorer {
+    /**
+     * Term frequency saturation parameter.
+     * Higher values give more weight to repeated terms.
+     * Typical range: 1.2 - 2.0
+     */
+    private readonly k1;
+    /**
+     * Document length normalization parameter.
+     * 0 = no length normalization
+     * 1 = full length normalization
+     * Typical value: 0.75
+     */
+    private readonly b;
+    /**
+     * Create a new BM25 scorer.
+     *
+     * @param options - BM25 configuration options
+     */
+    constructor(options?: BM25Options);
+    /**
+     * Score documents against a query.
+     *
+     * @param queryTerms - Array of query terms (already tokenized/stemmed)
+     * @param index - The inverted index to search
+     * @returns Array of scored documents, sorted by relevance (descending)
+     */
+    score(queryTerms: string[], index: BM25InvertedIndex): ScoredDocument[];
+    /**
+     * Score a single document against query terms.
+     * Uses pre-computed IDF from index but calculates TF locally.
+     *
+     * Complexity: O(Q × D) where Q = query terms, D = document tokens
+     *
+     * @param queryTerms - Tokenized query terms
+     * @param docTokens - Tokenized document terms
+     * @param index - Inverted index for IDF and avgDocLength
+     * @returns BM25 score (0 if no matching terms)
+     */
+    scoreSingleDocument(queryTerms: string[], docTokens: string[], index: BM25InvertedIndex): number;
+    /**
+     * Get the k1 parameter value.
+     */
+    getK1(): number;
+    /**
+     * Get the b parameter value.
+     */
+    getB(): number;
+}
+
+/**
+ * Full-Text Index
+ *
+ * High-level integration class that combines Tokenizer, InvertedIndex,
+ * and BM25Scorer for complete full-text search functionality.
+ * Designed to integrate with TopGun's CRDT maps.
+ *
+ * @module fts/FullTextIndex
+ */
+
+/**
+ * Full-Text Index for TopGun
+ *
+ * Provides BM25-based full-text search across document fields.
+ * Supports incremental updates (add/update/remove) for real-time sync.
+ *
+ * @example
+ * ```typescript
+ * const index = new FullTextIndex({
+ *   fields: ['title', 'body'],
+ *   tokenizer: { minLength: 2 },
+ *   bm25: { k1: 1.2, b: 0.75 }
+ * });
+ *
+ * index.onSet('doc1', { title: 'Hello World', body: 'Test content' });
+ * const results = index.search('hello');
+ * // [{ docId: 'doc1', score: 0.5, matchedTerms: ['hello'] }]
+ * ```
+ */
+declare class FullTextIndex {
+    /** Fields to index from documents */
+    private readonly fields;
+    /** Tokenizer for text processing */
+    private readonly tokenizer;
+    /** BM25 scorer for relevance ranking */
+    private readonly scorer;
+    /** Per-field inverted indexes for field boosting */
+    private readonly fieldIndexes;
+    /** Combined index for all fields */
+    private combinedIndex;
+    /** Track indexed documents */
+    private readonly indexedDocs;
+    /** Serializer for persistence */
+    private readonly serializer;
+    /**
+     * Cache of document tokens for fast single-document scoring.
+     * Maps docId → tokenized terms from all indexed fields.
+     */
+    private readonly documentTokensCache;
+    /**
+     * Create a new FullTextIndex.
+     *
+     * @param config - Index configuration
+     */
+    constructor(config: FullTextIndexConfig);
+    /**
+     * Index a document (add or update).
+     * Called when a document is set in the CRDT map.
+     *
+     * @param docId - Document identifier
+     * @param document - Document data containing fields to index
+     */
+    onSet(docId: string, document: Record<string, unknown> | null | undefined): void;
+    /**
+     * Remove a document from the index.
+     * Called when a document is deleted from the CRDT map.
+     *
+     * @param docId - Document identifier to remove
+     */
+    onRemove(docId: string): void;
+    /**
+     * Search the index with a query.
+     *
+     * @param query - Search query text
+     * @param options - Search options (limit, minScore, boost)
+     * @returns Array of search results, sorted by relevance
+     */
+    search(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Serialize the index state.
+     *
+     * @returns Serialized index data
+     */
+    serialize(): SerializedIndex;
+    /**
+     * Load index from serialized state.
+     *
+     * @param data - Serialized index data
+     */
+    load(data: SerializedIndex): void;
+    /**
+     * Build the index from an array of entries.
+     * Useful for initial bulk loading.
+     *
+     * @param entries - Array of [docId, document] tuples
+     */
+    buildFromEntries(entries: Array<[string, Record<string, unknown> | null]>): void;
+    /**
+     * Clear all data from the index.
+     */
+    clear(): void;
+    /**
+     * Get the number of indexed documents.
+     *
+     * @returns Number of documents in the index
+     */
+    getSize(): number;
+    /**
+     * Tokenize a query string using the index's tokenizer.
+     * Public method for external use (e.g., SearchCoordinator).
+     *
+     * @param query - Query text to tokenize
+     * @returns Array of tokenized terms
+     */
+    tokenizeQuery(query: string): string[];
+    /**
+     * Score a single document against query terms.
+     * O(Q × D) complexity where Q = query terms, D = document tokens.
+     *
+     * This method is optimized for checking if a single document
+     * matches a query, avoiding full index scan.
+     *
+     * @param docId - Document ID to score
+     * @param queryTerms - Pre-tokenized query terms
+     * @param document - Optional document data (used if not in cache)
+     * @returns SearchResult with score and matched terms, or null if no match
+     */
+    scoreSingleDocument(docId: string, queryTerms: string[], document?: Record<string, unknown>): SearchResult | null;
+    /**
+     * Tokenize all indexed fields of a document.
+     * Internal helper for scoreSingleDocument when document not in cache.
+     *
+     * @param document - Document data
+     * @returns Array of all tokens from indexed fields
+     */
+    private tokenizeDocument;
+    /**
+     * Get the index name (for debugging/display).
+     *
+     * @returns Descriptive name including indexed fields
+     */
+    get name(): string;
+    /**
+     * Remove document from all indexes (internal).
+     */
+    private removeFromIndexes;
+    /**
+     * Search with field boosting.
+     * Scores are computed per-field and combined with boost weights.
+     */
+    private searchWithBoost;
+}
+
+/**
+ * SetResultSet Implementation
+ *
+ * ResultSet backed by a Set, used for HashIndex results.
+ *
+ * @module query/resultset/SetResultSet
+ */
+
+/**
+ * ResultSet backed by a Set.
+ * Provides O(1) contains() check and direct iteration.
+ */
+declare class SetResultSet<K> implements ResultSet<K> {
+    private readonly keys;
+    private readonly retrievalCost;
+    constructor(keys: Set<K>, retrievalCost: number);
+    [Symbol.iterator](): Iterator<K>;
+    getRetrievalCost(): number;
+    getMergeCost(): number;
+    contains(key: K): boolean;
+    size(): number;
+    toArray(): K[];
+    isEmpty(): boolean;
+}
+
+/**
+ * LazyResultSet Implementation
+ *
+ * Lazily evaluated result set for range queries.
+ * Used when materializing all results upfront would be expensive.
+ *
+ * @module query/resultset/LazyResultSet
+ */
+
+/**
+ * Factory function type that creates a generator for lazy iteration.
+ */
+type IteratorFactory<K> = () => Generator<K>;
+/**
+ * Lazily evaluated result set.
+ * Used for range queries where materializing all results upfront is expensive.
+ *
+ * K = record key type
+ */
+declare class LazyResultSet<K> implements ResultSet<K> {
+    private readonly iteratorFactory;
+    private readonly retrievalCost;
+    private readonly estimatedSize;
+    /** Cached materialized results */
+    private cached;
+    /**
+     * Create a LazyResultSet.
+     *
+     * @param iteratorFactory - Factory that creates a fresh generator each time
+     * @param retrievalCost - Cost of retrieving results from the index
+     * @param estimatedSize - Estimated result count for merge cost calculation
+     */
+    constructor(iteratorFactory: IteratorFactory<K>, retrievalCost: number, estimatedSize: number);
+    [Symbol.iterator](): Generator<K>;
+    getRetrievalCost(): number;
+    getMergeCost(): number;
+    contains(key: K): boolean;
+    size(): number;
+    toArray(): K[];
+    isEmpty(): boolean;
+    /**
+     * Check if the result set has been materialized.
+     * Useful for testing lazy evaluation behavior.
+     */
+    isMaterialized(): boolean;
+    /**
+     * Force materialization of the result set.
+     * Returns the cached array.
+     */
+    materialize(): K[];
+    /**
+     * Get the estimated size before materialization.
+     */
+    getEstimatedSize(): number;
+}
+
+/**
+ * IntersectionResultSet Implementation
+ *
+ * Intersection of multiple result sets (AND logic).
+ * Implements CQEngine "smallest first" strategy:
+ * iterate the smallest set, check membership in others.
+ *
+ * @module query/resultset/IntersectionResultSet
+ */
+
+/**
+ * Intersection of multiple result sets (AND logic).
+ * CQEngine strategy: iterate smallest set, check membership in others.
+ *
+ * K = record key type
+ */
+declare class IntersectionResultSet<K> implements ResultSet<K> {
+    /** Cached materialized results */
+    private cached;
+    /** Result sets sorted by merge cost */
+    private sortedResultSets;
+    /**
+     * Create an IntersectionResultSet.
+     *
+     * @param resultSets - Result sets to intersect
+     */
+    constructor(resultSets: ResultSet<K>[]);
+    /**
+     * Lazy iteration over intersection.
+     * Iterates smallest set, yields only keys present in all sets.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Retrieval cost is minimum of all (we only iterate smallest).
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost is estimated as smallest set size (upper bound).
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in all result sets.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size by materializing results.
+     */
+    size(): number;
+    /**
+     * Materialize to array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty (tries to avoid full materialization).
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+}
+
+/**
+ * UnionResultSet Implementation
+ *
+ * Union of multiple result sets (OR logic).
+ * Deduplicates results using a Set during iteration.
+ *
+ * @module query/resultset/UnionResultSet
+ */
+
+/**
+ * Union of multiple result sets (OR logic).
+ * Deduplicates results.
  *
  * K = record key type
  */
@@ -5740,6 +6524,21 @@ interface QueryOptimizerOptions<K, V> {
     indexRegistry: IndexRegistry<K, V>;
     /** Standing query registry for pre-computed queries (optional) */
     standingQueryRegistry?: StandingQueryRegistry<K, V>;
+    /** Full-text index registry for FTS queries (Phase 12) */
+    fullTextIndexes?: Map<string, FullTextIndex>;
+}
+/**
+ * Classified predicates by type for hybrid query planning.
+ */
+interface ClassifiedPredicates {
+    /** Exact match predicates (eq, neq, in) */
+    exactPredicates: Query[];
+    /** Range predicates (gt, gte, lt, lte, between) */
+    rangePredicates: Query[];
+    /** Full-text search predicates (match, matchPhrase, matchPrefix) */
+    ftsPredicates: FTSQueryNode[];
+    /** Other predicates (like, regex, contains, etc.) */
+    otherPredicates: Query[];
 }
 /**
  * Cost-based query optimizer.
@@ -5750,6 +6549,7 @@ interface QueryOptimizerOptions<K, V> {
 declare class QueryOptimizer<K, V> {
     private readonly indexRegistry;
     private readonly standingQueryRegistry?;
+    private readonly fullTextIndexes;
     /**
      * Create a QueryOptimizer.
      *
@@ -5757,6 +6557,33 @@ declare class QueryOptimizer<K, V> {
      * @param standingQueryRegistry - Optional StandingQueryRegistry (deprecated, use options)
      */
     constructor(indexRegistryOrOptions: IndexRegistry<K, V> | QueryOptimizerOptions<K, V>, standingQueryRegistry?: StandingQueryRegistry<K, V>);
+    /**
+     * Register a full-text index for a field (Phase 12).
+     *
+     * @param field - Field name
+     * @param index - FullTextIndex instance
+     */
+    registerFullTextIndex(field: string, index: FullTextIndex): void;
+    /**
+     * Unregister a full-text index (Phase 12).
+     *
+     * @param field - Field name
+     */
+    unregisterFullTextIndex(field: string): void;
+    /**
+     * Get registered full-text index for a field (Phase 12).
+     *
+     * @param field - Field name
+     * @returns FullTextIndex or undefined
+     */
+    getFullTextIndex(field: string): FullTextIndex | undefined;
+    /**
+     * Check if a full-text index exists for a field (Phase 12).
+     *
+     * @param field - Field name
+     * @returns True if FTS index exists
+     */
+    hasFullTextIndex(field: string): boolean;
     /**
      * Optimize a query and return an execution plan.
      *
@@ -5780,6 +6607,41 @@ declare class QueryOptimizer<K, V> {
      * Optimize a single query node.
      */
     private optimizeNode;
+    /**
+     * Optimize a full-text search query (Phase 12).
+     */
+    private optimizeFTS;
+    /**
+     * Build an FTS scan step from a query node (Phase 12).
+     */
+    private buildFTSScanStep;
+    /**
+     * Estimate cost of FTS query based on index size (Phase 12).
+     */
+    private estimateFTSCost;
+    /**
+     * Classify predicates by type for hybrid query planning (Phase 12).
+     *
+     * @param predicates - Array of predicates to classify
+     * @returns Classified predicates
+     */
+    classifyPredicates(predicates: Query[]): ClassifiedPredicates;
+    /**
+     * Determine fusion strategy based on step types (Phase 12).
+     *
+     * Strategy selection:
+     * - All binary (exact/range with no scores) → 'intersection'
+     * - All scored (FTS) → 'score-filter' (filter by score, sort by score)
+     * - Mixed (binary + scored) → 'rrf' (Reciprocal Rank Fusion)
+     *
+     * @param steps - Plan steps to fuse
+     * @returns Fusion strategy
+     */
+    determineFusionStrategy(steps: PlanStep[]): FusionStrategy;
+    /**
+     * Check if a plan step returns scored results (Phase 12).
+     */
+    private stepReturnsScored;
     /**
      * Optimize a simple (attribute-based) query.
      */
@@ -6674,472 +7536,152 @@ declare class IndexedLWWMap<K extends string, V> extends LWWMap<K, V> {
     /**
      * Get current live query results (snapshot).
      *
-     * @param query - Query to execute
-     * @returns Array of matching keys
-     */
-    getLiveQueryResults(query: Query): K[];
-    /**
-     * Check if a query has active subscribers.
-     *
-     * @param query - Query to check
-     * @returns true if query has subscribers
-     */
-    hasLiveQuerySubscribers(query: Query): boolean;
-    /**
-     * Set a value (with index updates).
-     */
-    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
-    /**
-     * Remove a value (with index updates).
-     */
-    remove(key: K): LWWRecord<V>;
-    /**
-     * Merge a remote record (with index updates).
-     */
-    merge(key: K, remote: LWWRecord<V>): boolean;
-    /**
-     * Clear all data (and indexes).
-     */
-    clear(): void;
-    /**
-     * Returns all keys (non-tombstoned, non-expired).
-     */
-    keys(): Iterable<K>;
-    /**
-     * Get index statistics.
-     */
-    getIndexStats(): Map<string, IndexStats>;
-    /**
-     * Get index registry statistics.
-     */
-    getIndexRegistryStats(): IndexRegistryStats;
-    /**
-     * Get query optimizer for plan inspection.
-     */
-    getQueryOptimizer(): QueryOptimizer<K, V>;
-    /**
-     * Get live query manager for direct access.
-     */
-    getLiveQueryManager(): LiveQueryManager<K, V>;
-    /**
-     * Get standing query registry for direct access.
-     */
-    getStandingQueryRegistry(): StandingQueryRegistry<K, V>;
-    /**
-     * Explain query execution plan.
-     *
-     * @param query - Query to explain
-     * @returns Query execution plan
-     */
-    explainQuery(query: Query): QueryPlan;
-    /**
-     * Register an attribute for auto-indexing.
-     * Required before auto-index can create indexes on this attribute.
-     *
-     * @param attribute - The attribute to register
-     * @param allowedIndexTypes - Optional list of allowed index types
-     */
-    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
-    /**
-     * Unregister an attribute from auto-indexing.
-     *
-     * @param attributeName - Name of attribute to unregister
-     */
-    unregisterAttribute(attributeName: string): void;
-    /**
-     * Get index suggestions based on query patterns.
-     * Use this in production to get recommendations for manual index creation.
-     *
-     * @param options - Suggestion options
-     * @returns Array of index suggestions sorted by priority
-     *
-     * @example
-     * ```typescript
-     * const suggestions = products.getIndexSuggestions();
-     * // [{ attribute: 'category', indexType: 'hash', priority: 'high', ... }]
-     * ```
-     */
-    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
-    /**
-     * Get query pattern statistics.
-     * Useful for debugging and understanding query patterns.
-     *
-     * @returns Array of query statistics
-     */
-    getQueryStatistics(): QueryStatistics[];
-    /**
-     * Reset query statistics.
-     * Call this to clear accumulated query patterns.
-     */
-    resetQueryStatistics(): void;
-    /**
-     * Get query pattern tracker for advanced usage.
-     */
-    getQueryTracker(): QueryPatternTracker;
-    /**
-     * Get index advisor for advanced usage.
-     */
-    getIndexAdvisor(): IndexAdvisor;
-    /**
-     * Get auto-index manager (if enabled).
-     */
-    getAutoIndexManager(): AutoIndexManager<K, V> | null;
-    /**
-     * Check if auto-indexing is enabled.
-     */
-    isAutoIndexingEnabled(): boolean;
-    /**
-     * Check if lazy index building is enabled.
-     */
-    isLazyIndexingEnabled(): boolean;
-    /**
-     * Force materialization of all lazy indexes.
-     * Useful to pre-warm indexes before critical operations.
-     *
-     * @param progressCallback - Optional progress callback
+     * @param query - Query to execute
+     * @returns Array of matching keys
      */
-    materializeAllIndexes(progressCallback?: IndexBuildProgressCallback): void;
+    getLiveQueryResults(query: Query): K[];
     /**
-     * Get count of pending records across all lazy indexes.
-     * Returns 0 if no lazy indexes or all are materialized.
+     * Check if a query has active subscribers.
+     *
+     * @param query - Query to check
+     * @returns true if query has subscribers
      */
-    getPendingIndexCount(): number;
+    hasLiveQuerySubscribers(query: Query): boolean;
     /**
-     * Check if any lazy indexes are still pending (not built).
+     * Set a value (with index updates).
      */
-    hasUnbuiltIndexes(): boolean;
+    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
     /**
-     * Track query pattern for adaptive indexing.
+     * Remove a value (with index updates).
      */
-    private trackQueryPattern;
+    remove(key: K): LWWRecord<V>;
     /**
-     * Extract attribute name from query.
+     * Merge a remote record (with index updates).
      */
-    private extractAttribute;
+    merge(key: K, remote: LWWRecord<V>): boolean;
     /**
-     * Extract query type from query.
+     * Clear all data (and indexes).
      */
-    private extractQueryType;
-}
-
-/**
- * Full-Text Search Types
- *
- * Type definitions for the FTS (Full-Text Search) module.
- * This module provides BM25-based keyword search capabilities.
- *
- * @module fts/types
- */
-/**
- * Options for configuring the FTS Tokenizer.
- */
-interface TokenizerOptions {
+    clear(): void;
     /**
-     * Convert all text to lowercase before tokenization.
-     * @default true
+     * Returns all keys (non-tombstoned, non-expired).
      */
-    lowercase?: boolean;
+    keys(): Iterable<K>;
     /**
-     * Set of words to exclude from tokenization (e.g., "the", "and", "is").
-     * @default ENGLISH_STOPWORDS (174 words)
+     * Get index statistics.
      */
-    stopwords?: Set<string>;
+    getIndexStats(): Map<string, IndexStats>;
     /**
-     * Function to reduce words to their root form.
-     * @default Porter stemmer
+     * Get index registry statistics.
      */
-    stemmer?: (word: string) => string;
+    getIndexRegistryStats(): IndexRegistryStats;
     /**
-     * Minimum token length to include in results.
-     * @default 2
+     * Get query optimizer for plan inspection.
      */
-    minLength?: number;
+    getQueryOptimizer(): QueryOptimizer<K, V>;
     /**
-     * Maximum token length to include in results.
-     * @default 40
+     * Get live query manager for direct access.
      */
-    maxLength?: number;
-}
-/**
- * Information about a term's occurrence in a document.
- */
-interface TermInfo {
-    /** Document ID where the term appears */
-    docId: string;
-    /** Number of times the term appears in the document */
-    termFrequency: number;
-    /** Optional: positions of the term for phrase search (future) */
-    fieldPositions?: number[];
-}
-/**
- * Posting list entry for the inverted index.
- */
-interface Posting {
-    /** Document ID */
-    docId: string;
-    /** Term frequency in this document */
-    termFrequency: number;
-    /** Optional: positions for phrase search */
-    positions?: number[];
-}
-/**
- * BM25 algorithm configuration options.
- */
-interface BM25Options {
+    getLiveQueryManager(): LiveQueryManager<K, V>;
     /**
-     * Term frequency saturation parameter.
-     * Higher values give more weight to repeated terms.
-     * @default 1.2
+     * Get standing query registry for direct access.
      */
-    k1?: number;
+    getStandingQueryRegistry(): StandingQueryRegistry<K, V>;
     /**
-     * Document length normalization parameter.
-     * 0 = no length normalization, 1 = full normalization.
-     * @default 0.75
+     * Explain query execution plan.
+     *
+     * @param query - Query to explain
+     * @returns Query execution plan
      */
-    b?: number;
-}
-/**
- * A document with its BM25 relevance score.
- */
-interface ScoredDocument {
-    /** Document ID */
-    docId: string;
-    /** BM25 relevance score */
-    score: number;
-    /** Terms from the query that matched this document */
-    matchedTerms: string[];
-}
-/**
- * Configuration for a FullTextIndex.
- */
-interface FullTextIndexConfig {
-    /** Fields to index for full-text search (e.g., ['title', 'body']) */
-    fields: string[];
-    /** Tokenizer configuration */
-    tokenizer?: TokenizerOptions;
-    /** BM25 scoring parameters */
-    bm25?: BM25Options;
-}
-/**
- * Options for search queries.
- */
-interface SearchOptions {
-    /** Maximum number of results to return */
-    limit?: number;
-    /** Minimum BM25 score threshold */
-    minScore?: number;
-    /** Restrict search to specific fields */
-    fields?: string[];
-    /** Field boost weights (e.g., { title: 2.0, body: 1.0 }) */
-    boost?: Record<string, number>;
-}
-/**
- * Search result with full details.
- */
-interface SearchResult {
-    /** Document ID */
-    docId: string;
-    /** BM25 relevance score */
-    score: number;
-    /** Source of the match (for hybrid search) */
-    source?: 'exact' | 'fulltext' | 'vector' | 'bfs';
-    /** Original document data (if requested) */
-    data?: unknown;
-    /** Highlighted text snippet (if requested) */
-    highlightedText?: string;
-    /** Terms that matched */
-    matchedTerms?: string[];
-    /** Document embedding (if available) */
-    embedding?: number[];
-    /** Cosine similarity to query (0-1) */
-    embeddingSimilarity?: number;
-    /** Debug information */
-    debug?: {
-        exactScore?: number;
-        fulltextScore?: number;
-        vectorScore?: number;
-        rangeScore?: number;
-    };
-}
-/**
- * Serialized format for index persistence.
- */
-interface SerializedIndex {
-    /** Schema version for backwards compatibility */
-    version: number;
-    /** Index metadata */
-    metadata: {
-        totalDocs: number;
-        avgDocLength: number;
-        createdAt: number;
-        lastModified: number;
-    };
-    /** Serialized term data */
-    terms: Array<{
-        term: string;
-        idf: number;
-        postings: Array<{
-            docId: string;
-            termFrequency: number;
-            positions?: number[];
-        }>;
-    }>;
-    /** Document lengths for BM25 normalization */
-    docLengths: Record<string, number>;
-}
-
-/**
- * Full-Text Index
- *
- * High-level integration class that combines Tokenizer, InvertedIndex,
- * and BM25Scorer for complete full-text search functionality.
- * Designed to integrate with TopGun's CRDT maps.
- *
- * @module fts/FullTextIndex
- */
-
-/**
- * Full-Text Index for TopGun
- *
- * Provides BM25-based full-text search across document fields.
- * Supports incremental updates (add/update/remove) for real-time sync.
- *
- * @example
- * ```typescript
- * const index = new FullTextIndex({
- *   fields: ['title', 'body'],
- *   tokenizer: { minLength: 2 },
- *   bm25: { k1: 1.2, b: 0.75 }
- * });
- *
- * index.onSet('doc1', { title: 'Hello World', body: 'Test content' });
- * const results = index.search('hello');
- * // [{ docId: 'doc1', score: 0.5, matchedTerms: ['hello'] }]
- * ```
- */
-declare class FullTextIndex {
-    /** Fields to index from documents */
-    private readonly fields;
-    /** Tokenizer for text processing */
-    private readonly tokenizer;
-    /** BM25 scorer for relevance ranking */
-    private readonly scorer;
-    /** Per-field inverted indexes for field boosting */
-    private readonly fieldIndexes;
-    /** Combined index for all fields */
-    private combinedIndex;
-    /** Track indexed documents */
-    private readonly indexedDocs;
-    /** Serializer for persistence */
-    private readonly serializer;
+    explainQuery(query: Query): QueryPlan;
     /**
-     * Cache of document tokens for fast single-document scoring.
-     * Maps docId → tokenized terms from all indexed fields.
+     * Register an attribute for auto-indexing.
+     * Required before auto-index can create indexes on this attribute.
+     *
+     * @param attribute - The attribute to register
+     * @param allowedIndexTypes - Optional list of allowed index types
      */
-    private readonly documentTokensCache;
+    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
     /**
-     * Create a new FullTextIndex.
+     * Unregister an attribute from auto-indexing.
      *
-     * @param config - Index configuration
+     * @param attributeName - Name of attribute to unregister
      */
-    constructor(config: FullTextIndexConfig);
+    unregisterAttribute(attributeName: string): void;
     /**
-     * Index a document (add or update).
-     * Called when a document is set in the CRDT map.
+     * Get index suggestions based on query patterns.
+     * Use this in production to get recommendations for manual index creation.
      *
-     * @param docId - Document identifier
-     * @param document - Document data containing fields to index
+     * @param options - Suggestion options
+     * @returns Array of index suggestions sorted by priority
+     *
+     * @example
+     * ```typescript
+     * const suggestions = products.getIndexSuggestions();
+     * // [{ attribute: 'category', indexType: 'hash', priority: 'high', ... }]
+     * ```
      */
-    onSet(docId: string, document: Record<string, unknown> | null | undefined): void;
+    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
     /**
-     * Remove a document from the index.
-     * Called when a document is deleted from the CRDT map.
+     * Get query pattern statistics.
+     * Useful for debugging and understanding query patterns.
      *
-     * @param docId - Document identifier to remove
+     * @returns Array of query statistics
      */
-    onRemove(docId: string): void;
+    getQueryStatistics(): QueryStatistics[];
     /**
-     * Search the index with a query.
-     *
-     * @param query - Search query text
-     * @param options - Search options (limit, minScore, boost)
-     * @returns Array of search results, sorted by relevance
+     * Reset query statistics.
+     * Call this to clear accumulated query patterns.
      */
-    search(query: string, options?: SearchOptions): SearchResult[];
+    resetQueryStatistics(): void;
     /**
-     * Serialize the index state.
-     *
-     * @returns Serialized index data
+     * Get query pattern tracker for advanced usage.
      */
-    serialize(): SerializedIndex;
+    getQueryTracker(): QueryPatternTracker;
     /**
-     * Load index from serialized state.
-     *
-     * @param data - Serialized index data
+     * Get index advisor for advanced usage.
      */
-    load(data: SerializedIndex): void;
+    getIndexAdvisor(): IndexAdvisor;
     /**
-     * Build the index from an array of entries.
-     * Useful for initial bulk loading.
-     *
-     * @param entries - Array of [docId, document] tuples
+     * Get auto-index manager (if enabled).
      */
-    buildFromEntries(entries: Array<[string, Record<string, unknown> | null]>): void;
+    getAutoIndexManager(): AutoIndexManager<K, V> | null;
     /**
-     * Clear all data from the index.
+     * Check if auto-indexing is enabled.
      */
-    clear(): void;
+    isAutoIndexingEnabled(): boolean;
     /**
-     * Get the number of indexed documents.
-     *
-     * @returns Number of documents in the index
+     * Check if lazy index building is enabled.
      */
-    getSize(): number;
+    isLazyIndexingEnabled(): boolean;
     /**
-     * Tokenize a query string using the index's tokenizer.
-     * Public method for external use (e.g., SearchCoordinator).
+     * Force materialization of all lazy indexes.
+     * Useful to pre-warm indexes before critical operations.
      *
-     * @param query - Query text to tokenize
-     * @returns Array of tokenized terms
+     * @param progressCallback - Optional progress callback
      */
-    tokenizeQuery(query: string): string[];
+    materializeAllIndexes(progressCallback?: IndexBuildProgressCallback): void;
     /**
-     * Score a single document against query terms.
-     * O(Q × D) complexity where Q = query terms, D = document tokens.
-     *
-     * This method is optimized for checking if a single document
-     * matches a query, avoiding full index scan.
-     *
-     * @param docId - Document ID to score
-     * @param queryTerms - Pre-tokenized query terms
-     * @param document - Optional document data (used if not in cache)
-     * @returns SearchResult with score and matched terms, or null if no match
+     * Get count of pending records across all lazy indexes.
+     * Returns 0 if no lazy indexes or all are materialized.
      */
-    scoreSingleDocument(docId: string, queryTerms: string[], document?: Record<string, unknown>): SearchResult | null;
+    getPendingIndexCount(): number;
     /**
-     * Tokenize all indexed fields of a document.
-     * Internal helper for scoreSingleDocument when document not in cache.
-     *
-     * @param document - Document data
-     * @returns Array of all tokens from indexed fields
+     * Check if any lazy indexes are still pending (not built).
      */
-    private tokenizeDocument;
+    hasUnbuiltIndexes(): boolean;
     /**
-     * Get the index name (for debugging/display).
-     *
-     * @returns Descriptive name including indexed fields
+     * Track query pattern for adaptive indexing.
      */
-    get name(): string;
+    private trackQueryPattern;
     /**
-     * Remove document from all indexes (internal).
+     * Extract attribute name from query.
      */
-    private removeFromIndexes;
+    private extractAttribute;
     /**
-     * Search with field boosting.
-     * Scores are computed per-field and combined with boost weights.
+     * Extract query type from query.
      */
-    private searchWithBoost;
+    private extractQueryType;
 }
 
 /**
@@ -7375,385 +7917,212 @@ declare class IndexedORMap<K extends string, V> extends ORMap<K, V> {
     /**
      * Get record by composite key.
      */
-    private getRecordByCompositeKey;
-    /**
-     * Check if record matches predicate.
-     */
-    private matchesPredicate;
-    /**
-     * Check if record matches IndexQuery (used by FallbackIndex).
-     * This is a simplified matcher for full scan fallback.
-     */
-    private matchesIndexQuery;
-    /**
-     * Convert Query to PredicateNode format.
-     */
-    private queryToPredicate;
-    /**
-     * Get index statistics.
-     */
-    getIndexStats(): Map<string, IndexStats>;
-    /**
-     * Get index registry statistics.
-     */
-    getIndexRegistryStats(): IndexRegistryStats;
-    /**
-     * Get query optimizer for plan inspection.
-     */
-    getQueryOptimizer(): QueryOptimizer<string, V>;
-    /**
-     * Explain query execution plan.
-     *
-     * @param query - Query to explain
-     * @returns Query execution plan
-     */
-    explainQuery(query: Query): QueryPlan;
-    /**
-     * Register an attribute for auto-indexing.
-     * Required before auto-index can create indexes on this attribute.
-     *
-     * @param attribute - The attribute to register
-     * @param allowedIndexTypes - Optional list of allowed index types
-     */
-    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
-    /**
-     * Unregister an attribute from auto-indexing.
-     *
-     * @param attributeName - Name of attribute to unregister
-     */
-    unregisterAttribute(attributeName: string): void;
-    /**
-     * Get index suggestions based on query patterns.
-     * Use this in production to get recommendations for manual index creation.
-     *
-     * @param options - Suggestion options
-     * @returns Array of index suggestions sorted by priority
-     */
-    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
-    /**
-     * Get query pattern statistics.
-     * Useful for debugging and understanding query patterns.
-     *
-     * @returns Array of query statistics
-     */
-    getQueryStatistics(): QueryStatistics[];
-    /**
-     * Reset query statistics.
-     * Call this to clear accumulated query patterns.
-     */
-    resetQueryStatistics(): void;
-    /**
-     * Get query pattern tracker for advanced usage.
-     */
-    getQueryTracker(): QueryPatternTracker;
-    /**
-     * Get index advisor for advanced usage.
-     */
-    getIndexAdvisor(): IndexAdvisor;
-    /**
-     * Get auto-index manager (if enabled).
-     */
-    getAutoIndexManager(): AutoIndexManager<string, V> | null;
-    /**
-     * Check if auto-indexing is enabled.
-     */
-    isAutoIndexingEnabled(): boolean;
-    /**
-     * Track query pattern for adaptive indexing.
-     */
-    private trackQueryPattern;
-    /**
-     * Extract attribute name from query.
-     */
-    private extractAttribute;
-    /**
-     * Extract query type from query.
-     */
-    private extractQueryType;
-}
-
-/**
- * English stopwords list (174 common words).
- * These words are filtered out during tokenization as they
- * don't contribute to search relevance.
- */
-declare const ENGLISH_STOPWORDS: Set<string>;
-
-/**
- * Porter Stemming Algorithm
- *
- * Reduces English words to their stem (root form).
- * Based on the algorithm by Martin Porter (1980).
- *
- * @see https://tartarus.org/martin/PorterStemmer/
- *
- * @param word - Word to stem (should be lowercase)
- * @returns Stemmed word
- */
-declare function porterStem(word: string): string;
-
-/**
- * FTS Tokenizer with Porter Stemming and Stopwords
- *
- * Provides text tokenization for BM25 full-text search.
- * Features:
- * - Unicode-aware word boundary detection
- * - English stopwords filtering (174 words)
- * - Porter stemming algorithm for word normalization
- * - Configurable min/max token length
- *
- * @module fts/Tokenizer
- */
-
-/**
- * FTS Tokenizer
- *
- * Splits text into searchable tokens with normalization.
- *
- * @example
- * ```typescript
- * const tokenizer = new BM25Tokenizer();
- * const tokens = tokenizer.tokenize('The quick brown foxes');
- * // ['quick', 'brown', 'fox']
- * ```
- */
-declare class BM25Tokenizer implements Tokenizer {
-    private readonly options;
+    private getRecordByCompositeKey;
     /**
-     * Create a new BM25Tokenizer.
-     *
-     * @param options - Configuration options
+     * Check if record matches predicate.
      */
-    constructor(options?: TokenizerOptions);
+    private matchesPredicate;
     /**
-     * Tokenize text into an array of normalized tokens.
-     *
-     * @param text - Text to tokenize
-     * @returns Array of tokens
+     * Check if record matches IndexQuery (used by FallbackIndex).
+     * This is a simplified matcher for full scan fallback.
      */
-    tokenize(text: string): string[];
-}
-
-/**
- * FTS Inverted Index
- *
- * Data structure for full-text search that maps terms to documents.
- * Supports efficient term lookup, document frequency calculation,
- * and IDF (Inverse Document Frequency) for BM25 scoring.
- *
- * @module fts/BM25InvertedIndex
- */
-
-/**
- * Inverted Index for Full-Text Search (BM25)
- *
- * Maps terms to the documents containing them, along with term frequency
- * information needed for BM25 scoring.
- *
- * @example
- * ```typescript
- * const index = new BM25InvertedIndex();
- * index.addDocument('doc1', ['hello', 'world']);
- * index.addDocument('doc2', ['hello', 'there']);
- *
- * const docs = index.getDocumentsForTerm('hello');
- * // [{ docId: 'doc1', termFrequency: 1 }, { docId: 'doc2', termFrequency: 1 }]
- * ```
- */
-declare class BM25InvertedIndex {
-    /** term → list of documents containing term */
-    private index;
-    /** document → total term count (for length normalization) */
-    private docLengths;
-    /** document → set of terms (for efficient removal) */
-    private docTerms;
-    /** Inverse Document Frequency cache */
-    private idfCache;
-    /** Total number of documents */
-    private totalDocs;
-    /** Average document length */
-    private avgDocLength;
-    constructor();
+    private matchesIndexQuery;
     /**
-     * Add a document to the index.
-     *
-     * @param docId - Unique document identifier
-     * @param tokens - Array of tokens (already tokenized/stemmed)
+     * Convert Query to PredicateNode format.
      */
-    addDocument(docId: string, tokens: string[]): void;
+    private queryToPredicate;
     /**
-     * Remove a document from the index.
-     *
-     * @param docId - Document identifier to remove
+     * Get index statistics.
      */
-    removeDocument(docId: string): void;
+    getIndexStats(): Map<string, IndexStats>;
     /**
-     * Get all documents containing a term.
-     *
-     * @param term - Term to look up
-     * @returns Array of TermInfo objects
+     * Get index registry statistics.
      */
-    getDocumentsForTerm(term: string): TermInfo[];
+    getIndexRegistryStats(): IndexRegistryStats;
     /**
-     * Calculate IDF (Inverse Document Frequency) for a term.
-     *
-     * Uses BM25 IDF formula:
-     * IDF = log((N - df + 0.5) / (df + 0.5) + 1)
-     *
-     * Where:
-     * - N = total documents
-     * - df = document frequency (docs containing term)
-     *
-     * @param term - Term to calculate IDF for
-     * @returns IDF value (0 if term doesn't exist)
+     * Get query optimizer for plan inspection.
      */
-    getIDF(term: string): number;
+    getQueryOptimizer(): QueryOptimizer<string, V>;
     /**
-     * Get the length of a document (number of tokens).
+     * Explain query execution plan.
      *
-     * @param docId - Document identifier
-     * @returns Document length (0 if not found)
+     * @param query - Query to explain
+     * @returns Query execution plan
      */
-    getDocLength(docId: string): number;
+    explainQuery(query: Query): QueryPlan;
     /**
-     * Get the average document length.
+     * Register an attribute for auto-indexing.
+     * Required before auto-index can create indexes on this attribute.
      *
-     * @returns Average length across all documents
+     * @param attribute - The attribute to register
+     * @param allowedIndexTypes - Optional list of allowed index types
      */
-    getAvgDocLength(): number;
+    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
     /**
-     * Get the total number of documents in the index.
+     * Unregister an attribute from auto-indexing.
      *
-     * @returns Total document count
+     * @param attributeName - Name of attribute to unregister
      */
-    getTotalDocs(): number;
+    unregisterAttribute(attributeName: string): void;
     /**
-     * Get iterator for document lengths (useful for serialization).
+     * Get index suggestions based on query patterns.
+     * Use this in production to get recommendations for manual index creation.
      *
-     * @returns Iterator of [docId, length] pairs
+     * @param options - Suggestion options
+     * @returns Array of index suggestions sorted by priority
      */
-    getDocLengths(): IterableIterator<[string, number]>;
+    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
     /**
-     * Get the number of documents in the index (alias for getTotalDocs).
+     * Get query pattern statistics.
+     * Useful for debugging and understanding query patterns.
      *
-     * @returns Number of indexed documents
+     * @returns Array of query statistics
      */
-    getSize(): number;
+    getQueryStatistics(): QueryStatistics[];
     /**
-     * Clear all data from the index.
+     * Reset query statistics.
+     * Call this to clear accumulated query patterns.
      */
-    clear(): void;
+    resetQueryStatistics(): void;
     /**
-     * Check if a document exists in the index.
-     *
-     * @param docId - Document identifier
-     * @returns True if document exists
+     * Get query pattern tracker for advanced usage.
      */
-    hasDocument(docId: string): boolean;
+    getQueryTracker(): QueryPatternTracker;
     /**
-     * Get all unique terms in the index.
-     *
-     * @returns Iterator of all terms
+     * Get index advisor for advanced usage.
      */
-    getTerms(): IterableIterator<string>;
+    getIndexAdvisor(): IndexAdvisor;
     /**
-     * Get the number of unique terms in the index.
-     *
-     * @returns Number of unique terms
+     * Get auto-index manager (if enabled).
      */
-    getTermCount(): number;
+    getAutoIndexManager(): AutoIndexManager<string, V> | null;
     /**
-     * Update the average document length after add/remove.
+     * Check if auto-indexing is enabled.
      */
-    private updateAvgDocLength;
+    isAutoIndexingEnabled(): boolean;
+    /**
+     * Track query pattern for adaptive indexing.
+     */
+    private trackQueryPattern;
+    /**
+     * Extract attribute name from query.
+     */
+    private extractAttribute;
+    /**
+     * Extract query type from query.
+     */
+    private extractQueryType;
 }
 
 /**
- * BM25 Scorer
+ * Reciprocal Rank Fusion (RRF)
  *
- * Implements the Okapi BM25 ranking algorithm for full-text search.
- * BM25 is a probabilistic relevance ranking function used to estimate
- * the relevance of documents to a given search query.
+ * Implements RRF algorithm for merging ranked results from multiple search methods.
+ * Used in hybrid queries that combine exact matches, range queries, and full-text search.
  *
- * @see https://en.wikipedia.org/wiki/Okapi_BM25
- * @module fts/BM25Scorer
+ * Formula: RRF_score(d) = Σ 1 / (k + rank_i(d))
+ *
+ * Reference: Cormack, Clarke, Buettcher (2009) - "Reciprocal Rank Fusion outperforms
+ * Condorcet and individual Rank Learning Methods"
+ *
+ * @module search/ReciprocalRankFusion
  */
-
 /**
- * BM25 Scorer for relevance ranking
- *
- * The BM25 formula:
- * score(D,Q) = Σ IDF(qi) × (f(qi,D) × (k1 + 1)) / (f(qi,D) + k1 × (1 - b + b × |D| / avgdl))
+ * A ranked result from a single search method.
+ */
+interface RankedResult {
+    /** Unique document identifier */
+    docId: string;
+    /** Original score from the search method (e.g., BM25 score) */
+    score: number;
+    /** Source of this result: 'exact' | 'fulltext' | 'range' | custom */
+    source: string;
+}
+/**
+ * Configuration for RRF algorithm.
+ */
+interface RRFConfig {
+    /**
+     * Ranking constant k.
+     * Higher values reduce the impact of high rankings.
+     * Default: 60 (standard value from literature)
+     */
+    k?: number;
+}
+/**
+ * Merged result with combined RRF score.
+ */
+interface MergedResult {
+    /** Unique document identifier */
+    docId: string;
+    /** Combined RRF score */
+    score: number;
+    /** Combined sources (e.g., "exact+fulltext") */
+    source: string;
+    /** Original scores from each source */
+    originalScores: Record<string, number>;
+}
+/**
+ * Reciprocal Rank Fusion implementation.
  *
- * Where:
- * - D = document
- * - Q = query
- * - qi = query term i
- * - f(qi,D) = term frequency of qi in D
- * - |D| = length of D (number of terms)
- * - avgdl = average document length
- * - k1 = term frequency saturation parameter (default: 1.2)
- * - b = document length normalization parameter (default: 0.75)
+ * Merges results from multiple ranked lists using the RRF formula.
+ * Documents appearing in multiple result sets get boosted scores.
  *
  * @example
  * ```typescript
- * const index = new BM25InvertedIndex();
- * index.addDocument('doc1', ['hello', 'world']);
- * index.addDocument('doc2', ['hello', 'there']);
+ * const rrf = new ReciprocalRankFusion({ k: 60 });
  *
- * const scorer = new BM25Scorer();
- * const results = scorer.score(['hello'], index);
- * // [{ docId: 'doc1', score: 0.28, matchedTerms: ['hello'] }, ...]
+ * const exactResults = [
+ *   { docId: 'doc1', score: 1.0, source: 'exact' },
+ *   { docId: 'doc2', score: 1.0, source: 'exact' },
+ * ];
+ *
+ * const ftsResults = [
+ *   { docId: 'doc2', score: 2.5, source: 'fulltext' },
+ *   { docId: 'doc3', score: 1.8, source: 'fulltext' },
+ * ];
+ *
+ * const merged = rrf.merge([exactResults, ftsResults]);
+ * // doc2 ranks highest (appears in both sets)
  * ```
  */
-declare class BM25Scorer {
-    /**
-     * Term frequency saturation parameter.
-     * Higher values give more weight to repeated terms.
-     * Typical range: 1.2 - 2.0
-     */
-    private readonly k1;
-    /**
-     * Document length normalization parameter.
-     * 0 = no length normalization
-     * 1 = full length normalization
-     * Typical value: 0.75
-     */
-    private readonly b;
+declare class ReciprocalRankFusion {
+    private readonly k;
+    constructor(config?: RRFConfig);
     /**
-     * Create a new BM25 scorer.
+     * Merge multiple ranked result lists using RRF.
      *
-     * @param options - BM25 configuration options
-     */
-    constructor(options?: BM25Options);
-    /**
-     * Score documents against a query.
+     * Formula: RRF_score(d) = Σ 1 / (k + rank_i(d))
      *
-     * @param queryTerms - Array of query terms (already tokenized/stemmed)
-     * @param index - The inverted index to search
-     * @returns Array of scored documents, sorted by relevance (descending)
+     * @param resultSets - Array of ranked result lists from different search methods
+     * @returns Merged results sorted by RRF score (descending)
      */
-    score(queryTerms: string[], index: BM25InvertedIndex): ScoredDocument[];
+    merge(resultSets: RankedResult[][]): MergedResult[];
     /**
-     * Score a single document against query terms.
-     * Uses pre-computed IDF from index but calculates TF locally.
+     * Merge with weighted RRF for different method priorities.
      *
-     * Complexity: O(Q × D) where Q = query terms, D = document tokens
+     * Weighted formula: RRF_score(d) = Σ weight_i * (1 / (k + rank_i(d)))
      *
-     * @param queryTerms - Tokenized query terms
-     * @param docTokens - Tokenized document terms
-     * @param index - Inverted index for IDF and avgDocLength
-     * @returns BM25 score (0 if no matching terms)
-     */
-    scoreSingleDocument(queryTerms: string[], docTokens: string[], index: BM25InvertedIndex): number;
-    /**
-     * Get the k1 parameter value.
+     * @param resultSets - Array of ranked result lists
+     * @param weights - Weights for each result set (same order as resultSets)
+     * @returns Merged results sorted by weighted RRF score (descending)
+     *
+     * @example
+     * ```typescript
+     * const rrf = new ReciprocalRankFusion();
+     *
+     * // Prioritize exact matches (weight 2.0) over FTS (weight 1.0)
+     * const merged = rrf.mergeWeighted(
+     *   [exactResults, ftsResults],
+     *   [2.0, 1.0]
+     * );
+     * ```
      */
-    getK1(): number;
+    mergeWeighted(resultSets: RankedResult[][], weights: number[]): MergedResult[];
     /**
-     * Get the b parameter value.
+     * Get the k constant used for RRF calculation.
      */
-    getB(): number;
+    getK(): number;
 }
 
-export { type Attribute, AuthMessageSchema, type BM25Options, BM25Scorer, type BatchMessage, BatchMessageSchema, BuiltInProcessors, BuiltInResolvers, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type CompareFn, type ConflictResolver, type ConflictResolverDef, ConflictResolverDefSchema, type ConflictResolverFn, ConflictResolverSchema, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, CounterRequestSchema, CounterResponseSchema, CounterSyncSchema, CounterUpdateSchema, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_EVENT_JOURNAL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_PROCESSOR_RATE_LIMITS, DEFAULT_REPLICATION_CONFIG, DEFAULT_RESOLVER_RATE_LIMITS, DEFAULT_STOP_WORDS, DEFAULT_WRITE_CONCERN_TIMEOUT, ENGLISH_STOPWORDS, type EntryProcessBatchRequest, EntryProcessBatchRequestSchema, type EntryProcessBatchResponse, EntryProcessBatchResponseSchema, type EntryProcessKeyResult, EntryProcessKeyResultSchema, type EntryProcessRequest, EntryProcessRequestSchema, type EntryProcessResponse, EntryProcessResponseSchema, type EntryProcessorDef, EntryProcessorDefSchema, type EntryProcessorFn, type EntryProcessorResult, EntryProcessorSchema, type EventJournal, type EventJournalConfig, EventJournalImpl, FORBIDDEN_PATTERNS, BM25InvertedIndex as FTSInvertedIndex, type SearchOptions as FTSSearchOptions, type SearchResult as FTSSearchResult, BM25Tokenizer as FTSTokenizer, type TokenizerOptions as FTSTokenizerOptions, FallbackIndex, type FilterStep, FilteringResultSet, type FullScanStep, FullTextIndex, type FullTextIndexConfig, HLC, HashIndex, type Index, type IndexQuery, IndexRegistry, type IndexRegistryStats, type IndexScanStep, type IndexStats, IndexedLWWMap, IndexedORMap, IntersectionResultSet, type IntersectionStep, InvertedIndex, type InvertedIndexStats, type IteratorFactory, type JournalEvent, type JournalEventData, JournalEventDataSchema, type JournalEventInput, type JournalEventListener, type JournalEventMessage, JournalEventMessageSchema, type JournalEventType, JournalEventTypeSchema, type JournalReadRequest, JournalReadRequestSchema, type JournalReadResponse, JournalReadResponseSchema, type JournalSubscribeRequest, JournalSubscribeRequestSchema, type JournalUnsubscribeRequest, JournalUnsubscribeRequestSchema, LWWMap, type LWWRecord, LWWRecordSchema, LazyResultSet, LimitResultSet, type ListResolversRequest, ListResolversRequestSchema, type ListResolversResponse, ListResolversResponseSchema, type LiveQueryCallback, type LiveQueryDeltaEvent, type LiveQueryEvent, type LiveQueryInitialEvent, LiveQueryManager, type LiveQueryManagerOptions, type LiveQueryManagerStats, LockReleaseSchema, LockRequestSchema, type LogicalQueryNode, LowercaseFilter, MaxLengthFilter, type MergeContext, type MergeKeyResult, type MergeRejectedMessage, MergeRejectedMessageSchema, type MergeRejection, type MergeResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, MinLengthFilter, MultiValueAttribute, NGramTokenizer, NavigableIndex, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, type NotStep, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapQueryResult, type ORMapRecord, ORMapRecordSchema, type ORMapSearchResult, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PNCounter, type PNCounterConfig, PNCounterImpl, type PNCounterState, type PNCounterStateObject, PNCounterStateObjectSchema, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PlanStep, type PongMessage, PongMessageSchema, type Posting, type PredicateFn, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type ProcessorRateLimitConfig, type Query$1 as Query, type Query as QueryExpression, type QueryNode, QueryOptimizer, type QueryOptimizerOptions, type QueryOptions, type QueryPlan, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, RESOLVER_FORBIDDEN_PATTERNS, type RegisterResolverRequest, RegisterResolverRequestSchema, type RegisterResolverResponse, RegisterResolverResponseSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type ResolverRateLimitConfig, type ResultSet, Ringbuffer, type RoutingError, type ScoredDocument, type SearchMessage, SearchMessageSchema, type SearchOptions$1 as SearchOptions, SearchOptionsSchema, type SearchPayload, SearchPayloadSchema, type SearchRespMessage, SearchRespMessageSchema, type SearchRespPayload, SearchRespPayloadSchema, type SearchSubMessage, SearchSubMessageSchema, type SearchSubPayload, SearchSubPayloadSchema, type SearchUnsubMessage, SearchUnsubMessageSchema, type SearchUnsubPayload, SearchUnsubPayloadSchema, type SearchUpdateMessage, SearchUpdateMessageSchema, type SearchUpdatePayload, SearchUpdatePayloadSchema, type SearchUpdateType, SearchUpdateTypeSchema, type SerializedIndex, SetResultSet, SimpleAttribute, type SimpleQueryNode, SortedMap, SortedResultSet, type StaleMapError, type StandingQueryChange, StandingQueryIndex, type StandingQueryIndexOptions, StandingQueryRegistry, type StandingQueryRegistryOptions, type StandingQueryRegistryStats, StopWordFilter, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type TermInfo, type Timestamp, TimestampSchema, type TokenFilter, TokenizationPipeline, type TokenizationPipelineOptions, type Tokenizer, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, TrimFilter, UnionResultSet, type UnionStep, UniqueFilter, type UnregisterResolverRequest, UnregisterResolverRequestSchema, type UnregisterResolverResponse, UnregisterResolverResponseSchema, WRITE_CONCERN_ORDER, WhitespaceTokenizer, WordBoundaryTokenizer, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareHLCTimestamps, compareTimestamps, createFieldComparator, createPredicateMatcher, deepMerge, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isLogicalQuery, isSimpleQuery, isUsingNativeHash, isWriteConcernAchieved, multiAttribute, porterStem, resetNativeHash, serialize, simpleAttribute, timestampToString, validateProcessorCode, validateResolverCode };
+export { type Attribute, AuthMessageSchema, type BM25Options, BM25Scorer, type BatchMessage, BatchMessageSchema, BuiltInProcessors, BuiltInResolvers, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type CompareFn, type ConflictResolver, type ConflictResolverDef, ConflictResolverDefSchema, type ConflictResolverFn, ConflictResolverSchema, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, CounterRequestSchema, CounterResponseSchema, CounterSyncSchema, CounterUpdateSchema, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_EVENT_JOURNAL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_PROCESSOR_RATE_LIMITS, DEFAULT_REPLICATION_CONFIG, DEFAULT_RESOLVER_RATE_LIMITS, DEFAULT_STOP_WORDS, DEFAULT_WRITE_CONCERN_TIMEOUT, ENGLISH_STOPWORDS, type EntryProcessBatchRequest, EntryProcessBatchRequestSchema, type EntryProcessBatchResponse, EntryProcessBatchResponseSchema, type EntryProcessKeyResult, EntryProcessKeyResultSchema, type EntryProcessRequest, EntryProcessRequestSchema, type EntryProcessResponse, EntryProcessResponseSchema, type EntryProcessorDef, EntryProcessorDefSchema, type EntryProcessorFn, type EntryProcessorResult, EntryProcessorSchema, type EventJournal, type EventJournalConfig, EventJournalImpl, FORBIDDEN_PATTERNS, BM25InvertedIndex as FTSInvertedIndex, type SearchOptions as FTSSearchOptions, type SearchResult as FTSSearchResult, BM25Tokenizer as FTSTokenizer, type TokenizerOptions as FTSTokenizerOptions, FallbackIndex, type FilterStep, FilteringResultSet, type FullScanStep, FullTextIndex, type FullTextIndexConfig, HLC, HashIndex, type Index, type IndexQuery, IndexRegistry, type IndexRegistryStats, type IndexScanStep, type IndexStats, IndexedLWWMap, IndexedORMap, IntersectionResultSet, type IntersectionStep, InvertedIndex, type InvertedIndexStats, type IteratorFactory, type JournalEvent, type JournalEventData, JournalEventDataSchema, type JournalEventInput, type JournalEventListener, type JournalEventMessage, JournalEventMessageSchema, type JournalEventType, JournalEventTypeSchema, type JournalReadRequest, JournalReadRequestSchema, type JournalReadResponse, JournalReadResponseSchema, type JournalSubscribeRequest, JournalSubscribeRequestSchema, type JournalUnsubscribeRequest, JournalUnsubscribeRequestSchema, LWWMap, type LWWRecord, LWWRecordSchema, LazyResultSet, LimitResultSet, type ListResolversRequest, ListResolversRequestSchema, type ListResolversResponse, ListResolversResponseSchema, type LiveQueryCallback, type LiveQueryDeltaEvent, type LiveQueryEvent, type LiveQueryInitialEvent, LiveQueryManager, type LiveQueryManagerOptions, type LiveQueryManagerStats, LockReleaseSchema, LockRequestSchema, type LogicalQueryNode, LowercaseFilter, type MatchOptions, MaxLengthFilter, type MergeContext, type MergeKeyResult, type MergeRejectedMessage, MergeRejectedMessageSchema, type MergeRejection, type MergeResult, type MergedResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, MinLengthFilter, MultiValueAttribute, NGramTokenizer, NavigableIndex, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, type NotStep, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapQueryResult, type ORMapRecord, ORMapRecordSchema, type ORMapSearchResult, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PNCounter, type PNCounterConfig, PNCounterImpl, type PNCounterState, type PNCounterStateObject, PNCounterStateObjectSchema, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PlanStep, type PongMessage, PongMessageSchema, type Posting, type PredicateFn, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type ProcessorRateLimitConfig, type Query$1 as Query, type Query as QueryExpression, type QueryNode, QueryOptimizer, type QueryOptimizerOptions, type QueryOptions, type QueryPlan, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, RESOLVER_FORBIDDEN_PATTERNS, type RRFConfig, type RankedResult, ReciprocalRankFusion, type RegisterResolverRequest, RegisterResolverRequestSchema, type RegisterResolverResponse, RegisterResolverResponseSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type ResolverRateLimitConfig, type ResultSet, Ringbuffer, type RoutingError, type ScoredDocument, type SearchMessage, SearchMessageSchema, type SearchOptions$1 as SearchOptions, SearchOptionsSchema, type SearchPayload, SearchPayloadSchema, type SearchRespMessage, SearchRespMessageSchema, type SearchRespPayload, SearchRespPayloadSchema, type SearchSubMessage, SearchSubMessageSchema, type SearchSubPayload, SearchSubPayloadSchema, type SearchUnsubMessage, SearchUnsubMessageSchema, type SearchUnsubPayload, SearchUnsubPayloadSchema, type SearchUpdateMessage, SearchUpdateMessageSchema, type SearchUpdatePayload, SearchUpdatePayloadSchema, type SearchUpdateType, SearchUpdateTypeSchema, type SerializedIndex, SetResultSet, SimpleAttribute, type SimpleQueryNode, SortedMap, SortedResultSet, type StaleMapError, type StandingQueryChange, StandingQueryIndex, type StandingQueryIndexOptions, StandingQueryRegistry, type StandingQueryRegistryOptions, type StandingQueryRegistryStats, StopWordFilter, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type TermInfo, type Timestamp, TimestampSchema, type TokenFilter, TokenizationPipeline, type TokenizationPipelineOptions, type Tokenizer, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, TrimFilter, UnionResultSet, type UnionStep, UniqueFilter, type UnregisterResolverRequest, UnregisterResolverRequestSchema, type UnregisterResolverResponse, UnregisterResolverResponseSchema, WRITE_CONCERN_ORDER, WhitespaceTokenizer, WordBoundaryTokenizer, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareHLCTimestamps, compareTimestamps, createFieldComparator, createPredicateMatcher, deepMerge, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isLogicalQuery, isSimpleQuery, isUsingNativeHash, isWriteConcernAchieved, multiAttribute, porterStem, resetNativeHash, serialize, simpleAttribute, timestampToString, validateProcessorCode, validateResolverCode };