@topgunbuild/core 0.7.0 → 0.8.1

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;
 
@@ -1897,6 +1996,147 @@ declare const JournalReadResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     hasMore: z.ZodBoolean;
 }, z.core.$strip>;
+/**
+ * Search options schema for FTS queries.
+ */
+declare const SearchOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    minScore: z.ZodOptional<z.ZodNumber>;
+    boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * SEARCH: Client requests one-shot BM25 search.
+ */
+declare const SearchPayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    query: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        minScore: z.ZodOptional<z.ZodNumber>;
+        boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SearchMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            minScore: z.ZodOptional<z.ZodNumber>;
+            boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * SEARCH_RESP: Server responds with search results.
+ */
+declare const SearchRespPayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnknown;
+        score: z.ZodNumber;
+        matchedTerms: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    totalCount: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SearchRespMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_RESP">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        results: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnknown;
+            score: z.ZodNumber;
+            matchedTerms: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Search delta update type.
+ * - ENTER: Document entered the result set (new or score exceeded minScore)
+ * - UPDATE: Document score changed while remaining in result set
+ * - LEAVE: Document left the result set (removed or score dropped below minScore)
+ */
+declare const SearchUpdateTypeSchema: z.ZodEnum<{
+    UPDATE: "UPDATE";
+    ENTER: "ENTER";
+    LEAVE: "LEAVE";
+}>;
+/**
+ * SEARCH_SUB: Client subscribes to live search results.
+ */
+declare const SearchSubPayloadSchema: z.ZodObject<{
+    subscriptionId: z.ZodString;
+    mapName: z.ZodString;
+    query: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        minScore: z.ZodOptional<z.ZodNumber>;
+        boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SearchSubMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_SUB">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            minScore: z.ZodOptional<z.ZodNumber>;
+            boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * SEARCH_UPDATE: Server sends delta update for a subscribed search.
+ */
+declare const SearchUpdatePayloadSchema: z.ZodObject<{
+    subscriptionId: z.ZodString;
+    key: z.ZodString;
+    value: z.ZodUnknown;
+    score: z.ZodNumber;
+    matchedTerms: z.ZodArray<z.ZodString>;
+    type: z.ZodEnum<{
+        UPDATE: "UPDATE";
+        ENTER: "ENTER";
+        LEAVE: "LEAVE";
+    }>;
+}, z.core.$strip>;
+declare const SearchUpdateMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_UPDATE">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodUnknown;
+        score: z.ZodNumber;
+        matchedTerms: z.ZodArray<z.ZodString>;
+        type: z.ZodEnum<{
+            UPDATE: "UPDATE";
+            ENTER: "ENTER";
+            LEAVE: "LEAVE";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * SEARCH_UNSUB: Client unsubscribes from live search.
+ */
+declare const SearchUnsubPayloadSchema: z.ZodObject<{
+    subscriptionId: z.ZodString;
+}, z.core.$strip>;
+declare const SearchUnsubMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_UNSUB">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Conflict resolver definition schema (wire format).
  */
@@ -2488,6 +2728,62 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         priority: z.ZodOptional<z.ZodNumber>;
         keyPattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            minScore: z.ZodOptional<z.ZodNumber>;
+            boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_RESP">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        results: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnknown;
+            score: z.ZodNumber;
+            matchedTerms: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_SUB">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            minScore: z.ZodOptional<z.ZodNumber>;
+            boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_UPDATE">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodUnknown;
+        score: z.ZodNumber;
+        matchedTerms: z.ZodArray<z.ZodString>;
+        type: z.ZodEnum<{
+            UPDATE: "UPDATE";
+            ENTER: "ENTER";
+            LEAVE: "LEAVE";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SEARCH_UNSUB">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+    }, z.core.$strip>;
 }, z.core.$strip>], "type">;
 type Query$1 = z.infer<typeof QuerySchema>;
 type ClientOp = z.infer<typeof ClientOpSchema>;
@@ -2517,6 +2813,18 @@ type UnregisterResolverResponse = z.infer<typeof UnregisterResolverResponseSchem
 type MergeRejectedMessage = z.infer<typeof MergeRejectedMessageSchema>;
 type ListResolversRequest = z.infer<typeof ListResolversRequestSchema>;
 type ListResolversResponse = z.infer<typeof ListResolversResponseSchema>;
+type SearchOptions$1 = z.infer<typeof SearchOptionsSchema>;
+type SearchPayload = z.infer<typeof SearchPayloadSchema>;
+type SearchMessage = z.infer<typeof SearchMessageSchema>;
+type SearchRespPayload = z.infer<typeof SearchRespPayloadSchema>;
+type SearchRespMessage = z.infer<typeof SearchRespMessageSchema>;
+type SearchUpdateType = z.infer<typeof SearchUpdateTypeSchema>;
+type SearchSubPayload = z.infer<typeof SearchSubPayloadSchema>;
+type SearchSubMessage = z.infer<typeof SearchSubMessageSchema>;
+type SearchUpdatePayload = z.infer<typeof SearchUpdatePayloadSchema>;
+type SearchUpdateMessage = z.infer<typeof SearchUpdateMessageSchema>;
+type SearchUnsubPayload = z.infer<typeof SearchUnsubPayloadSchema>;
+type SearchUnsubMessage = z.infer<typeof SearchUnsubMessageSchema>;
 
 /**
  * Write Concern - Configurable Acknowledgment Levels
@@ -3558,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.
  */
@@ -3569,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.
  */
@@ -3585,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.
  */
@@ -3631,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.
  */
@@ -4729,6 +5118,610 @@ declare class LazyInvertedIndex<K, V, A extends string = string> implements Lazy
     getTokenDocumentCount(token: string): number;
 }
 
+/**
+ * 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 {
+    /**
+     * Convert all text to lowercase before tokenization.
+     * @default true
+     */
+    lowercase?: boolean;
+    /**
+     * Set of words to exclude from tokenization (e.g., "the", "and", "is").
+     * @default ENGLISH_STOPWORDS (174 words)
+     */
+    stopwords?: Set<string>;
+    /**
+     * Function to reduce words to their root form.
+     * @default Porter stemmer
+     */
+    stemmer?: (word: string) => string;
+    /**
+     * Minimum token length to include in results.
+     * @default 2
+     */
+    minLength?: number;
+    /**
+     * Maximum token length to include in results.
+     * @default 40
+     */
+    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 {
+    /**
+     * Term frequency saturation parameter.
+     * Higher values give more weight to repeated terms.
+     * @default 1.2
+     */
+    k1?: number;
+    /**
+     * Document length normalization parameter.
+     * 0 = no length normalization, 1 = full normalization.
+     * @default 0.75
+     */
+    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>;
+}
+
+/**
+ * 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
  *
@@ -5531,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.
@@ -5541,6 +6549,7 @@ interface QueryOptimizerOptions<K, V> {
 declare class QueryOptimizer<K, V> {
     private readonly indexRegistry;
     private readonly standingQueryRegistry?;
+    private readonly fullTextIndexes;
     /**
      * Create a QueryOptimizer.
      *
@@ -5548,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.
      *
@@ -5571,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.
      */
@@ -6640,6 +7711,16 @@ interface ORMapQueryResult<K, V> {
     tag: string;
     value: V;
 }
+/**
+ * Result of a full-text search on IndexedORMap.
+ * Includes BM25 relevance score for ranking.
+ */
+interface ORMapSearchResult<K, V> extends ORMapQueryResult<K, V> {
+    /** BM25 relevance score */
+    score: number;
+    /** Terms from the query that matched */
+    matchedTerms: string[];
+}
 /**
  * ORMap with index support.
  *
@@ -6657,6 +7738,7 @@ declare class IndexedORMap<K extends string, V> extends ORMap<K, V> {
     private readonly autoIndexManager;
     private readonly defaultIndexingStrategy;
     private readonly options;
+    private fullTextIndex;
     constructor(hlc: HLC, options?: IndexedMapOptions);
     /**
      * Add a hash index on an attribute.
@@ -6689,6 +7771,59 @@ declare class IndexedORMap<K extends string, V> extends ORMap<K, V> {
      * @param index - Index to add
      */
     addIndex<A>(index: Index<string, V, A>): void;
+    /**
+     * Enable BM25-based full-text search on specified fields.
+     * This creates a FullTextIndex for relevance-ranked search.
+     *
+     * Note: This is different from addInvertedIndex which provides
+     * boolean matching (contains/containsAll/containsAny). This method
+     * provides BM25 relevance scoring for true full-text search.
+     *
+     * @param config - Full-text index configuration
+     * @returns The created FullTextIndex
+     *
+     * @example
+     * ```typescript
+     * const map = new IndexedORMap(hlc);
+     * map.enableFullTextSearch({
+     *   fields: ['title', 'body'],
+     *   tokenizer: { minLength: 2 },
+     *   bm25: { k1: 1.2, b: 0.75 }
+     * });
+     *
+     * map.add('doc1', { title: 'Hello World', body: 'Test content' });
+     * const results = map.search('hello');
+     * // [{ key: 'doc1', tag: '...', value: {...}, score: 0.5, matchedTerms: ['hello'] }]
+     * ```
+     */
+    enableFullTextSearch(config: FullTextIndexConfig): FullTextIndex;
+    /**
+     * Check if full-text search is enabled.
+     *
+     * @returns true if full-text search is enabled
+     */
+    isFullTextSearchEnabled(): boolean;
+    /**
+     * Get the full-text index (if enabled).
+     *
+     * @returns The FullTextIndex or null
+     */
+    getFullTextIndex(): FullTextIndex | null;
+    /**
+     * Perform a BM25-ranked full-text search.
+     * Results are sorted by relevance score (highest first).
+     *
+     * @param query - Search query text
+     * @param options - Search options (limit, minScore, boost)
+     * @returns Array of search results with scores, sorted by relevance
+     *
+     * @throws Error if full-text search is not enabled
+     */
+    search(query: string, options?: SearchOptions): ORMapSearchResult<K, V>[];
+    /**
+     * Disable full-text search and release the index.
+     */
+    disableFullTextSearch(): void;
     /**
      * Remove an index.
      *
@@ -6879,4 +8014,115 @@ declare class IndexedORMap<K extends string, V> extends ORMap<K, V> {
     private extractQueryType;
 }
 
-export { type Attribute, AuthMessageSchema, 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, 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, FallbackIndex, type FilterStep, FilteringResultSet, type FullScanStep, 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 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 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, SetResultSet, SimpleAttribute, type SimpleQueryNode, SortedMap, SortedResultSet, type StaleMapError, type StandingQueryChange, StandingQueryIndex, type StandingQueryIndexOptions, StandingQueryRegistry, type StandingQueryRegistryOptions, type StandingQueryRegistryStats, StopWordFilter, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, 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, resetNativeHash, serialize, simpleAttribute, timestampToString, validateProcessorCode, validateResolverCode };
+/**
+ * Reciprocal Rank Fusion (RRF)
+ *
+ * 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.
+ *
+ * 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
+ */
+/**
+ * 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.
+ *
+ * Merges results from multiple ranked lists using the RRF formula.
+ * Documents appearing in multiple result sets get boosted scores.
+ *
+ * @example
+ * ```typescript
+ * const rrf = new ReciprocalRankFusion({ k: 60 });
+ *
+ * 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 ReciprocalRankFusion {
+    private readonly k;
+    constructor(config?: RRFConfig);
+    /**
+     * Merge multiple ranked result lists using RRF.
+     *
+     * Formula: RRF_score(d) = Σ 1 / (k + rank_i(d))
+     *
+     * @param resultSets - Array of ranked result lists from different search methods
+     * @returns Merged results sorted by RRF score (descending)
+     */
+    merge(resultSets: RankedResult[][]): MergedResult[];
+    /**
+     * Merge with weighted RRF for different method priorities.
+     *
+     * Weighted formula: RRF_score(d) = Σ weight_i * (1 / (k + rank_i(d)))
+     *
+     * @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]
+     * );
+     * ```
+     */
+    mergeWeighted(resultSets: RankedResult[][], weights: number[]): MergedResult[];
+    /**
+     * Get the k constant used for RRF calculation.
+     */
+    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, 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 };