@topgunbuild/core 0.7.0 → 0.8.1

package/dist/index.mjs

@@ -1973,6 +1973,95 @@ var Predicates = class {
   static containsAny(attribute, values) {
     return { op: "containsAny", attribute, value: values };
   }
+  // ============== Full-Text Search Predicates (Phase 12) ==============
+  /**
+   * 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, query, options) {
+    return { op: "match", attribute, query, matchOptions: options };
+  }
+  /**
+   * 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, query, slop) {
+    return { op: "matchPhrase", attribute, query, slop };
+  }
+  /**
+   * 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, prefix, maxExpansions) {
+    return { op: "matchPrefix", attribute, prefix, maxExpansions };
+  }
+  /**
+   * 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, query, options) {
+    const children = attributes.map((attr) => ({
+      op: "match",
+      attribute: attr,
+      query,
+      matchOptions: options?.boost?.[attr] ? { boost: options.boost[attr] } : void 0
+    }));
+    return { op: "or", children };
+  }
 };
 function evaluatePredicate(predicate, data) {
   if (!data) return false;
@@ -2416,6 +2505,66 @@ var JournalReadResponseSchema = z3.object({
   events: z3.array(JournalEventDataSchema),
   hasMore: z3.boolean()
 });
+var SearchOptionsSchema = z3.object({
+  limit: z3.number().optional(),
+  minScore: z3.number().optional(),
+  boost: z3.record(z3.string(), z3.number()).optional()
+});
+var SearchPayloadSchema = z3.object({
+  requestId: z3.string(),
+  mapName: z3.string(),
+  query: z3.string(),
+  options: SearchOptionsSchema.optional()
+});
+var SearchMessageSchema = z3.object({
+  type: z3.literal("SEARCH"),
+  payload: SearchPayloadSchema
+});
+var SearchRespPayloadSchema = z3.object({
+  requestId: z3.string(),
+  results: z3.array(z3.object({
+    key: z3.string(),
+    value: z3.unknown(),
+    score: z3.number(),
+    matchedTerms: z3.array(z3.string())
+  })),
+  totalCount: z3.number(),
+  error: z3.string().optional()
+});
+var SearchRespMessageSchema = z3.object({
+  type: z3.literal("SEARCH_RESP"),
+  payload: SearchRespPayloadSchema
+});
+var SearchUpdateTypeSchema = z3.enum(["ENTER", "UPDATE", "LEAVE"]);
+var SearchSubPayloadSchema = z3.object({
+  subscriptionId: z3.string(),
+  mapName: z3.string(),
+  query: z3.string(),
+  options: SearchOptionsSchema.optional()
+});
+var SearchSubMessageSchema = z3.object({
+  type: z3.literal("SEARCH_SUB"),
+  payload: SearchSubPayloadSchema
+});
+var SearchUpdatePayloadSchema = z3.object({
+  subscriptionId: z3.string(),
+  key: z3.string(),
+  value: z3.unknown(),
+  score: z3.number(),
+  matchedTerms: z3.array(z3.string()),
+  type: SearchUpdateTypeSchema
+});
+var SearchUpdateMessageSchema = z3.object({
+  type: z3.literal("SEARCH_UPDATE"),
+  payload: SearchUpdatePayloadSchema
+});
+var SearchUnsubPayloadSchema = z3.object({
+  subscriptionId: z3.string()
+});
+var SearchUnsubMessageSchema = z3.object({
+  type: z3.literal("SEARCH_UNSUB"),
+  payload: SearchUnsubPayloadSchema
+});
 var ConflictResolverSchema = z3.object({
   name: z3.string().min(1).max(100),
   code: z3.string().max(5e4),
@@ -2547,7 +2696,14 @@ var MessageSchema = z3.discriminatedUnion("type", [
   UnregisterResolverResponseSchema,
   MergeRejectedMessageSchema,
   ListResolversRequestSchema,
-  ListResolversResponseSchema
+  ListResolversResponseSchema,
+  // Phase 11.1: Full-Text Search
+  SearchMessageSchema,
+  SearchRespMessageSchema,
+  // Phase 11.1b: Live Search Subscriptions
+  SearchSubMessageSchema,
+  SearchUpdateMessageSchema,
+  SearchUnsubMessageSchema
 ]);
 
 // src/types/WriteConcern.ts
@@ -3528,6 +3684,9 @@ function isSimpleQuery(query) {
 function isLogicalQuery(query) {
   return query.type === "and" || query.type === "or" || query.type === "not";
 }
+function isFTSQuery(query) {
+  return query.type === "match" || query.type === "matchPhrase" || query.type === "matchPrefix";
+}
 
 // src/query/indexes/StandingQueryIndex.ts
 var _StandingQueryIndex = class _StandingQueryIndex {
@@ -5786,11 +5945,48 @@ var QueryOptimizer = class {
     if ("indexRegistry" in indexRegistryOrOptions) {
       this.indexRegistry = indexRegistryOrOptions.indexRegistry;
       this.standingQueryRegistry = indexRegistryOrOptions.standingQueryRegistry;
+      this.fullTextIndexes = indexRegistryOrOptions.fullTextIndexes ?? /* @__PURE__ */ new Map();
     } else {
       this.indexRegistry = indexRegistryOrOptions;
       this.standingQueryRegistry = standingQueryRegistry;
+      this.fullTextIndexes = /* @__PURE__ */ new Map();
     }
   }
+  /**
+   * Register a full-text index for a field (Phase 12).
+   *
+   * @param field - Field name
+   * @param index - FullTextIndex instance
+   */
+  registerFullTextIndex(field, index) {
+    this.fullTextIndexes.set(field, index);
+  }
+  /**
+   * Unregister a full-text index (Phase 12).
+   *
+   * @param field - Field name
+   */
+  unregisterFullTextIndex(field) {
+    this.fullTextIndexes.delete(field);
+  }
+  /**
+   * Get registered full-text index for a field (Phase 12).
+   *
+   * @param field - Field name
+   * @returns FullTextIndex or undefined
+   */
+  getFullTextIndex(field) {
+    return this.fullTextIndexes.get(field);
+  }
+  /**
+   * Check if a full-text index exists for a field (Phase 12).
+   *
+   * @param field - Field name
+   * @returns True if FTS index exists
+   */
+  hasFullTextIndex(field) {
+    return this.fullTextIndexes.has(field);
+  }
   /**
    * Optimize a query and return an execution plan.
    *
@@ -5864,12 +6060,151 @@ var QueryOptimizer = class {
   optimizeNode(query) {
     if (isLogicalQuery(query)) {
       return this.optimizeLogical(query);
+    } else if (isFTSQuery(query)) {
+      return this.optimizeFTS(query);
     } else if (isSimpleQuery(query)) {
       return this.optimizeSimple(query);
     } else {
       return { type: "full-scan", predicate: query };
     }
   }
+  /**
+   * Optimize a full-text search query (Phase 12).
+   */
+  optimizeFTS(query) {
+    const field = query.attribute;
+    if (!this.hasFullTextIndex(field)) {
+      return { type: "full-scan", predicate: query };
+    }
+    return this.buildFTSScanStep(query);
+  }
+  /**
+   * Build an FTS scan step from a query node (Phase 12).
+   */
+  buildFTSScanStep(query) {
+    const field = query.attribute;
+    switch (query.type) {
+      case "match":
+        return {
+          type: "fts-scan",
+          field,
+          query: query.query,
+          ftsType: "match",
+          options: query.options,
+          returnsScored: true,
+          estimatedCost: this.estimateFTSCost(field)
+        };
+      case "matchPhrase":
+        return {
+          type: "fts-scan",
+          field,
+          query: query.query,
+          ftsType: "matchPhrase",
+          options: query.slop !== void 0 ? { fuzziness: query.slop } : void 0,
+          returnsScored: true,
+          estimatedCost: this.estimateFTSCost(field)
+        };
+      case "matchPrefix":
+        return {
+          type: "fts-scan",
+          field,
+          query: query.prefix,
+          ftsType: "matchPrefix",
+          options: query.maxExpansions !== void 0 ? { fuzziness: query.maxExpansions } : void 0,
+          returnsScored: true,
+          estimatedCost: this.estimateFTSCost(field)
+        };
+      default:
+        throw new Error(`Unknown FTS query type: ${query.type}`);
+    }
+  }
+  /**
+   * Estimate cost of FTS query based on index size (Phase 12).
+   */
+  estimateFTSCost(field) {
+    const index = this.fullTextIndexes.get(field);
+    if (!index) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    const docCount = index.getSize();
+    return 50 + Math.log2(docCount + 1) * 10;
+  }
+  /**
+   * Classify predicates by type for hybrid query planning (Phase 12).
+   *
+   * @param predicates - Array of predicates to classify
+   * @returns Classified predicates
+   */
+  classifyPredicates(predicates) {
+    const result = {
+      exactPredicates: [],
+      rangePredicates: [],
+      ftsPredicates: [],
+      otherPredicates: []
+    };
+    for (const pred of predicates) {
+      if (isFTSQuery(pred)) {
+        result.ftsPredicates.push(pred);
+      } else if (isSimpleQuery(pred)) {
+        switch (pred.type) {
+          case "eq":
+          case "neq":
+          case "in":
+            result.exactPredicates.push(pred);
+            break;
+          case "gt":
+          case "gte":
+          case "lt":
+          case "lte":
+          case "between":
+            result.rangePredicates.push(pred);
+            break;
+          default:
+            result.otherPredicates.push(pred);
+        }
+      } else if (isLogicalQuery(pred)) {
+        result.otherPredicates.push(pred);
+      } else {
+        result.otherPredicates.push(pred);
+      }
+    }
+    return result;
+  }
+  /**
+   * 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) {
+    const hasScored = steps.some((s) => this.stepReturnsScored(s));
+    const hasBinary = steps.some((s) => !this.stepReturnsScored(s));
+    if (hasScored && hasBinary) {
+      return "rrf";
+    } else if (hasScored) {
+      return "score-filter";
+    } else {
+      return "intersection";
+    }
+  }
+  /**
+   * Check if a plan step returns scored results (Phase 12).
+   */
+  stepReturnsScored(step) {
+    switch (step.type) {
+      case "fts-scan":
+        return true;
+      case "fusion":
+        return step.returnsScored;
+      default:
+        return false;
+    }
+  }
   /**
    * Optimize a simple (attribute-based) query.
    */
@@ -6125,6 +6460,18 @@ var QueryOptimizer = class {
         return this.estimateCost(step.source) + 10;
       case "not":
         return this.estimateCost(step.source) + 100;
+      // Phase 12: FTS step types
+      case "fts-scan":
+        return step.estimatedCost;
+      case "fusion":
+        return step.steps.reduce((sum, s) => {
+          const cost = this.estimateCost(s);
+          if (cost === Number.MAX_SAFE_INTEGER) {
+            return Number.MAX_SAFE_INTEGER;
+          }
+          return Math.min(sum + cost, Number.MAX_SAFE_INTEGER);
+        }, 0) + 20;
+      // Fusion overhead
       default:
         return Number.MAX_SAFE_INTEGER;
     }
@@ -6145,6 +6492,12 @@ var QueryOptimizer = class {
         return this.usesIndexes(step.source);
       case "not":
         return this.usesIndexes(step.source);
+      // Phase 12: FTS step types
+      case "fts-scan":
+        return true;
+      // FTS uses FullTextIndex
+      case "fusion":
+        return step.steps.some((s) => this.usesIndexes(s));
       default:
         return false;
     }
@@ -7693,6 +8046,131 @@ var DefaultIndexingStrategy = class {
   }
 };
 
+// src/search/ReciprocalRankFusion.ts
+var ReciprocalRankFusion = class {
+  constructor(config) {
+    this.k = config?.k ?? 60;
+  }
+  /**
+   * 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) {
+    const nonEmptySets = resultSets.filter((set) => set.length > 0);
+    if (nonEmptySets.length === 0) {
+      return [];
+    }
+    const scoreMap = /* @__PURE__ */ new Map();
+    for (const resultSet of nonEmptySets) {
+      for (let rank = 0; rank < resultSet.length; rank++) {
+        const result = resultSet[rank];
+        const { docId, score, source } = result;
+        const rrfContribution = 1 / (this.k + rank + 1);
+        const existing = scoreMap.get(docId);
+        if (existing) {
+          existing.rrfScore += rrfContribution;
+          existing.sources.add(source);
+          existing.originalScores[source] = score;
+        } else {
+          scoreMap.set(docId, {
+            rrfScore: rrfContribution,
+            sources: /* @__PURE__ */ new Set([source]),
+            originalScores: { [source]: score }
+          });
+        }
+      }
+    }
+    const merged = [];
+    for (const [docId, data] of scoreMap) {
+      merged.push({
+        docId,
+        score: data.rrfScore,
+        source: Array.from(data.sources).sort().join("+"),
+        originalScores: data.originalScores
+      });
+    }
+    merged.sort((a, b) => b.score - a.score);
+    return merged;
+  }
+  /**
+   * 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, weights) {
+    if (weights.length !== resultSets.length) {
+      throw new Error(
+        `Weights array length (${weights.length}) must match resultSets length (${resultSets.length})`
+      );
+    }
+    const nonEmptyPairs = [];
+    for (let i = 0; i < resultSets.length; i++) {
+      if (resultSets[i].length > 0) {
+        nonEmptyPairs.push({ resultSet: resultSets[i], weight: weights[i] });
+      }
+    }
+    if (nonEmptyPairs.length === 0) {
+      return [];
+    }
+    const scoreMap = /* @__PURE__ */ new Map();
+    for (const { resultSet, weight } of nonEmptyPairs) {
+      for (let rank = 0; rank < resultSet.length; rank++) {
+        const result = resultSet[rank];
+        const { docId, score, source } = result;
+        const rrfContribution = weight * (1 / (this.k + rank + 1));
+        const existing = scoreMap.get(docId);
+        if (existing) {
+          existing.rrfScore += rrfContribution;
+          existing.sources.add(source);
+          existing.originalScores[source] = score;
+        } else {
+          scoreMap.set(docId, {
+            rrfScore: rrfContribution,
+            sources: /* @__PURE__ */ new Set([source]),
+            originalScores: { [source]: score }
+          });
+        }
+      }
+    }
+    const merged = [];
+    for (const [docId, data] of scoreMap) {
+      merged.push({
+        docId,
+        score: data.rrfScore,
+        source: Array.from(data.sources).sort().join("+"),
+        originalScores: data.originalScores
+      });
+    }
+    merged.sort((a, b) => b.score - a.score);
+    return merged;
+  }
+  /**
+   * Get the k constant used for RRF calculation.
+   */
+  getK() {
+    return this.k;
+  }
+};
+
 // src/IndexedLWWMap.ts
 var IndexedLWWMap = class extends LWWMap {
   constructor(hlc, options = {}) {
@@ -8449,49 +8927,1115 @@ var IndexedLWWMap = class extends LWWMap {
   }
 };
 
-// src/IndexedORMap.ts
-var IndexedORMap = class extends ORMap {
-  constructor(hlc, options = {}) {
-    super(hlc);
-    this.options = options;
-    this.indexRegistry = new IndexRegistry();
-    this.queryOptimizer = new QueryOptimizer({
-      indexRegistry: this.indexRegistry
-    });
-    this.indexRegistry.setFallbackIndex(
-      new FallbackIndex(
-        () => this.getAllCompositeKeys(),
-        (compositeKey) => this.getRecordByCompositeKey(compositeKey),
-        (record, query) => this.matchesIndexQuery(record, query)
-      )
-    );
-    this.queryTracker = new QueryPatternTracker();
-    this.indexAdvisor = new IndexAdvisor(this.queryTracker);
-    if (options.adaptiveIndexing?.autoIndex?.enabled) {
-      this.autoIndexManager = new AutoIndexManager(
-        this.queryTracker,
-        this.indexAdvisor,
-        options.adaptiveIndexing.autoIndex
-      );
-      this.autoIndexManager.setMap(this);
-    } else {
-      this.autoIndexManager = null;
+// src/query/tokenization/stopwords.ts
+var ENGLISH_STOPWORDS = /* @__PURE__ */ new Set([
+  // Articles
+  "a",
+  "an",
+  "the",
+  // Pronouns
+  "i",
+  "me",
+  "my",
+  "myself",
+  "we",
+  "our",
+  "ours",
+  "ourselves",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "yourselves",
+  "he",
+  "him",
+  "his",
+  "himself",
+  "she",
+  "her",
+  "hers",
+  "herself",
+  "it",
+  "its",
+  "itself",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "themselves",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "this",
+  "that",
+  "these",
+  "those",
+  // Auxiliary verbs
+  "am",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "having",
+  "do",
+  "does",
+  "did",
+  "doing",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "can",
+  "could",
+  "may",
+  "might",
+  "must",
+  "ought",
+  // Prepositions
+  "about",
+  "above",
+  "across",
+  "after",
+  "against",
+  "along",
+  "among",
+  "around",
+  "at",
+  "before",
+  "behind",
+  "below",
+  "beneath",
+  "beside",
+  "between",
+  "beyond",
+  "by",
+  "down",
+  "during",
+  "except",
+  "for",
+  "from",
+  "in",
+  "inside",
+  "into",
+  "near",
+  "of",
+  "off",
+  "on",
+  "onto",
+  "out",
+  "outside",
+  "over",
+  "past",
+  "since",
+  "through",
+  "throughout",
+  "to",
+  "toward",
+  "towards",
+  "under",
+  "underneath",
+  "until",
+  "up",
+  "upon",
+  "with",
+  "within",
+  "without",
+  // Conjunctions
+  "and",
+  "but",
+  "or",
+  "nor",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "not",
+  "only",
+  "as",
+  "if",
+  "than",
+  "when",
+  "while",
+  "although",
+  "because",
+  "unless",
+  "whether",
+  // Adverbs
+  "here",
+  "there",
+  "where",
+  "when",
+  "how",
+  "why",
+  "all",
+  "each",
+  "every",
+  "any",
+  "some",
+  "no",
+  "none",
+  "more",
+  "most",
+  "other",
+  "such",
+  "own",
+  "same",
+  "too",
+  "very",
+  "just",
+  "also",
+  "now",
+  "then",
+  "again",
+  "ever",
+  "once",
+  // Misc
+  "few",
+  "many",
+  "much",
+  "several",
+  "s",
+  "t",
+  "d",
+  "ll",
+  "m",
+  "ve",
+  "re"
+]);
+
+// src/query/tokenization/porter-stemmer.ts
+function porterStem(word) {
+  if (!word || word.length < 3) {
+    return word;
+  }
+  let stem = word;
+  if (stem.endsWith("sses")) {
+    stem = stem.slice(0, -2);
+  } else if (stem.endsWith("ies")) {
+    stem = stem.slice(0, -2);
+  } else if (!stem.endsWith("ss") && stem.endsWith("s")) {
+    stem = stem.slice(0, -1);
+  }
+  const step1bRegex = /^(.+?)(eed|ed|ing)$/;
+  const step1bMatch = stem.match(step1bRegex);
+  if (step1bMatch) {
+    const [, base, suffix] = step1bMatch;
+    if (suffix === "eed") {
+      if (getMeasure(base) > 0) {
+        stem = base + "ee";
+      }
+    } else if (hasVowel(base)) {
+      stem = base;
+      if (stem.endsWith("at") || stem.endsWith("bl") || stem.endsWith("iz")) {
+        stem = stem + "e";
+      } else if (endsWithDoubleConsonant(stem) && !stem.match(/[lsz]$/)) {
+        stem = stem.slice(0, -1);
+      } else if (getMeasure(stem) === 1 && endsWithCVC(stem)) {
+        stem = stem + "e";
+      }
+    }
+  }
+  if (stem.endsWith("y") && hasVowel(stem.slice(0, -1))) {
+    stem = stem.slice(0, -1) + "i";
+  }
+  const step2Suffixes = [
+    [/ational$/, "ate", 0],
+    [/tional$/, "tion", 0],
+    [/enci$/, "ence", 0],
+    [/anci$/, "ance", 0],
+    [/izer$/, "ize", 0],
+    [/abli$/, "able", 0],
+    [/alli$/, "al", 0],
+    [/entli$/, "ent", 0],
+    [/eli$/, "e", 0],
+    [/ousli$/, "ous", 0],
+    [/ization$/, "ize", 0],
+    [/ation$/, "ate", 0],
+    [/ator$/, "ate", 0],
+    [/alism$/, "al", 0],
+    [/iveness$/, "ive", 0],
+    [/fulness$/, "ful", 0],
+    [/ousness$/, "ous", 0],
+    [/aliti$/, "al", 0],
+    [/iviti$/, "ive", 0],
+    [/biliti$/, "ble", 0]
+  ];
+  for (const [regex, replacement, minMeasure] of step2Suffixes) {
+    if (regex.test(stem)) {
+      const base = stem.replace(regex, "");
+      if (getMeasure(base) > minMeasure) {
+        stem = base + replacement;
+        break;
+      }
     }
-    if (options.defaultIndexing && options.defaultIndexing !== "none") {
-      this.defaultIndexingStrategy = new DefaultIndexingStrategy(options.defaultIndexing);
-    } else {
-      this.defaultIndexingStrategy = null;
+  }
+  const step3Suffixes = [
+    [/icate$/, "ic", 0],
+    [/ative$/, "", 0],
+    [/alize$/, "al", 0],
+    [/iciti$/, "ic", 0],
+    [/ical$/, "ic", 0],
+    [/ful$/, "", 0],
+    [/ness$/, "", 0]
+  ];
+  for (const [regex, replacement, minMeasure] of step3Suffixes) {
+    if (regex.test(stem)) {
+      const base = stem.replace(regex, "");
+      if (getMeasure(base) > minMeasure) {
+        stem = base + replacement;
+        break;
+      }
     }
   }
-  // ==================== Index Management ====================
-  /**
-   * Add a hash index on an attribute.
-   *
-   * @param attribute - Attribute to index
-   * @returns Created HashIndex
-   */
-  addHashIndex(attribute) {
-    const index = new HashIndex(attribute);
+  const step4Suffixes = [
+    [/al$/, 1],
+    [/ance$/, 1],
+    [/ence$/, 1],
+    [/er$/, 1],
+    [/ic$/, 1],
+    [/able$/, 1],
+    [/ible$/, 1],
+    [/ant$/, 1],
+    [/ement$/, 1],
+    [/ment$/, 1],
+    [/ent$/, 1],
+    [/ion$/, 1],
+    [/ou$/, 1],
+    [/ism$/, 1],
+    [/ate$/, 1],
+    [/iti$/, 1],
+    [/ous$/, 1],
+    [/ive$/, 1],
+    [/ize$/, 1]
+  ];
+  for (const [regex, minMeasure] of step4Suffixes) {
+    if (regex.test(stem)) {
+      const base = stem.replace(regex, "");
+      if (getMeasure(base) > minMeasure) {
+        if (regex.source === "ion$") {
+          if (base.match(/[st]$/)) {
+            stem = base;
+          }
+        } else {
+          stem = base;
+        }
+        break;
+      }
+    }
+  }
+  if (stem.endsWith("e")) {
+    const base = stem.slice(0, -1);
+    const measure = getMeasure(base);
+    if (measure > 1 || measure === 1 && !endsWithCVC(base)) {
+      stem = base;
+    }
+  }
+  if (getMeasure(stem) > 1 && endsWithDoubleConsonant(stem) && stem.endsWith("l")) {
+    stem = stem.slice(0, -1);
+  }
+  return stem;
+}
+function isVowel(char, prevChar) {
+  if ("aeiou".includes(char)) {
+    return true;
+  }
+  if (char === "y" && prevChar && !"aeiou".includes(prevChar)) {
+    return true;
+  }
+  return false;
+}
+function hasVowel(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (isVowel(str[i], i > 0 ? str[i - 1] : void 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getMeasure(str) {
+  let pattern = "";
+  for (let i = 0; i < str.length; i++) {
+    pattern += isVowel(str[i], i > 0 ? str[i - 1] : void 0) ? "v" : "c";
+  }
+  const matches = pattern.match(/vc/g);
+  return matches ? matches.length : 0;
+}
+function endsWithDoubleConsonant(str) {
+  if (str.length < 2) return false;
+  const last = str[str.length - 1];
+  const secondLast = str[str.length - 2];
+  return last === secondLast && !"aeiou".includes(last);
+}
+function endsWithCVC(str) {
+  if (str.length < 3) return false;
+  const last3 = str.slice(-3);
+  const c1 = !"aeiou".includes(last3[0]);
+  const v = isVowel(last3[1], last3[0]);
+  const c2 = !"aeiou".includes(last3[2]) && !"wxy".includes(last3[2]);
+  return c1 && v && c2;
+}
+
+// src/fts/Tokenizer.ts
+var BM25Tokenizer = class {
+  /**
+   * Create a new BM25Tokenizer.
+   *
+   * @param options - Configuration options
+   */
+  constructor(options) {
+    this.options = {
+      lowercase: true,
+      stopwords: ENGLISH_STOPWORDS,
+      stemmer: porterStem,
+      minLength: 2,
+      maxLength: 40,
+      ...options
+    };
+  }
+  /**
+   * Tokenize text into an array of normalized tokens.
+   *
+   * @param text - Text to tokenize
+   * @returns Array of tokens
+   */
+  tokenize(text) {
+    if (!text || typeof text !== "string") {
+      return [];
+    }
+    let processed = this.options.lowercase ? text.toLowerCase() : text;
+    const words = processed.split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 0);
+    const tokens = [];
+    for (const word of words) {
+      if (word.length < this.options.minLength) {
+        continue;
+      }
+      if (this.options.stopwords.has(word)) {
+        continue;
+      }
+      const stemmed = this.options.stemmer(word);
+      if (stemmed.length < this.options.minLength) {
+        continue;
+      }
+      if (stemmed.length > this.options.maxLength) {
+        continue;
+      }
+      tokens.push(stemmed);
+    }
+    return tokens;
+  }
+};
+
+// src/fts/BM25InvertedIndex.ts
+var BM25InvertedIndex = class {
+  constructor() {
+    this.index = /* @__PURE__ */ new Map();
+    this.docLengths = /* @__PURE__ */ new Map();
+    this.docTerms = /* @__PURE__ */ new Map();
+    this.idfCache = /* @__PURE__ */ new Map();
+    this.totalDocs = 0;
+    this.avgDocLength = 0;
+  }
+  /**
+   * Add a document to the index.
+   *
+   * @param docId - Unique document identifier
+   * @param tokens - Array of tokens (already tokenized/stemmed)
+   */
+  addDocument(docId, tokens) {
+    const termFreqs = /* @__PURE__ */ new Map();
+    const uniqueTerms = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
+      uniqueTerms.add(token);
+    }
+    for (const [term, freq] of termFreqs) {
+      if (!this.index.has(term)) {
+        this.index.set(term, []);
+      }
+      this.index.get(term).push({
+        docId,
+        termFrequency: freq
+      });
+    }
+    this.docLengths.set(docId, tokens.length);
+    this.docTerms.set(docId, uniqueTerms);
+    this.totalDocs++;
+    this.updateAvgDocLength();
+    this.idfCache.clear();
+  }
+  /**
+   * Remove a document from the index.
+   *
+   * @param docId - Document identifier to remove
+   */
+  removeDocument(docId) {
+    const terms = this.docTerms.get(docId);
+    if (!terms) {
+      return;
+    }
+    for (const term of terms) {
+      const termInfos = this.index.get(term);
+      if (termInfos) {
+        const filtered = termInfos.filter((info) => info.docId !== docId);
+        if (filtered.length === 0) {
+          this.index.delete(term);
+        } else {
+          this.index.set(term, filtered);
+        }
+      }
+    }
+    this.docLengths.delete(docId);
+    this.docTerms.delete(docId);
+    this.totalDocs--;
+    this.updateAvgDocLength();
+    this.idfCache.clear();
+  }
+  /**
+   * Get all documents containing a term.
+   *
+   * @param term - Term to look up
+   * @returns Array of TermInfo objects
+   */
+  getDocumentsForTerm(term) {
+    return this.index.get(term) || [];
+  }
+  /**
+   * 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) {
+    if (this.idfCache.has(term)) {
+      return this.idfCache.get(term);
+    }
+    const termInfos = this.index.get(term);
+    if (!termInfos || termInfos.length === 0) {
+      return 0;
+    }
+    const docFreq = termInfos.length;
+    const idf = Math.log((this.totalDocs - docFreq + 0.5) / (docFreq + 0.5) + 1);
+    this.idfCache.set(term, idf);
+    return idf;
+  }
+  /**
+   * Get the length of a document (number of tokens).
+   *
+   * @param docId - Document identifier
+   * @returns Document length (0 if not found)
+   */
+  getDocLength(docId) {
+    return this.docLengths.get(docId) || 0;
+  }
+  /**
+   * Get the average document length.
+   *
+   * @returns Average length across all documents
+   */
+  getAvgDocLength() {
+    return this.avgDocLength;
+  }
+  /**
+   * Get the total number of documents in the index.
+   *
+   * @returns Total document count
+   */
+  getTotalDocs() {
+    return this.totalDocs;
+  }
+  /**
+   * Get iterator for document lengths (useful for serialization).
+   *
+   * @returns Iterator of [docId, length] pairs
+   */
+  getDocLengths() {
+    return this.docLengths.entries();
+  }
+  /**
+   * Get the number of documents in the index (alias for getTotalDocs).
+   *
+   * @returns Number of indexed documents
+   */
+  getSize() {
+    return this.totalDocs;
+  }
+  /**
+   * Clear all data from the index.
+   */
+  clear() {
+    this.index.clear();
+    this.docLengths.clear();
+    this.docTerms.clear();
+    this.idfCache.clear();
+    this.totalDocs = 0;
+    this.avgDocLength = 0;
+  }
+  /**
+   * Check if a document exists in the index.
+   *
+   * @param docId - Document identifier
+   * @returns True if document exists
+   */
+  hasDocument(docId) {
+    return this.docTerms.has(docId);
+  }
+  /**
+   * Get all unique terms in the index.
+   *
+   * @returns Iterator of all terms
+   */
+  getTerms() {
+    return this.index.keys();
+  }
+  /**
+   * Get the number of unique terms in the index.
+   *
+   * @returns Number of unique terms
+   */
+  getTermCount() {
+    return this.index.size;
+  }
+  /**
+   * Update the average document length after add/remove.
+   */
+  updateAvgDocLength() {
+    if (this.totalDocs === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    let sum = 0;
+    for (const length of this.docLengths.values()) {
+      sum += length;
+    }
+    this.avgDocLength = sum / this.totalDocs;
+  }
+};
+
+// src/fts/BM25Scorer.ts
+var BM25Scorer = class {
+  /**
+   * Create a new BM25 scorer.
+   *
+   * @param options - BM25 configuration options
+   */
+  constructor(options) {
+    this.k1 = options?.k1 ?? 1.2;
+    this.b = options?.b ?? 0.75;
+  }
+  /**
+   * 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, index) {
+    if (queryTerms.length === 0 || index.getTotalDocs() === 0) {
+      return [];
+    }
+    const avgDocLength = index.getAvgDocLength();
+    const docScores = /* @__PURE__ */ new Map();
+    for (const term of queryTerms) {
+      const idf = index.getIDF(term);
+      if (idf === 0) {
+        continue;
+      }
+      const termInfos = index.getDocumentsForTerm(term);
+      for (const { docId, termFrequency } of termInfos) {
+        const docLength = index.getDocLength(docId);
+        const numerator = termFrequency * (this.k1 + 1);
+        const denominator = termFrequency + this.k1 * (1 - this.b + this.b * (docLength / avgDocLength));
+        const termScore = idf * (numerator / denominator);
+        const current = docScores.get(docId) || { score: 0, terms: /* @__PURE__ */ new Set() };
+        current.score += termScore;
+        current.terms.add(term);
+        docScores.set(docId, current);
+      }
+    }
+    const results = [];
+    for (const [docId, { score, terms }] of docScores) {
+      results.push({
+        docId,
+        score,
+        matchedTerms: Array.from(terms)
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+  /**
+   * 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, docTokens, index) {
+    if (queryTerms.length === 0 || docTokens.length === 0) {
+      return 0;
+    }
+    const avgDocLength = index.getAvgDocLength();
+    const docLength = docTokens.length;
+    if (avgDocLength === 0) {
+      return 0;
+    }
+    const termFreqs = /* @__PURE__ */ new Map();
+    for (const token of docTokens) {
+      termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
+    }
+    let score = 0;
+    for (const term of queryTerms) {
+      const tf = termFreqs.get(term) || 0;
+      if (tf === 0) {
+        continue;
+      }
+      const idf = index.getIDF(term);
+      if (idf <= 0) {
+        continue;
+      }
+      const numerator = tf * (this.k1 + 1);
+      const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / avgDocLength));
+      const termScore = idf * (numerator / denominator);
+      score += termScore;
+    }
+    return score;
+  }
+  /**
+   * Get the k1 parameter value.
+   */
+  getK1() {
+    return this.k1;
+  }
+  /**
+   * Get the b parameter value.
+   */
+  getB() {
+    return this.b;
+  }
+};
+
+// src/fts/IndexSerializer.ts
+var IndexSerializer = class {
+  /**
+   * Serialize inverted index to a JSON-serializable object.
+   * Note: In a real app, you might want to encoding this to binary (msgpack) later.
+   */
+  serialize(index) {
+    const data = {
+      version: 1,
+      metadata: {
+        totalDocs: index.getTotalDocs(),
+        avgDocLength: index.getAvgDocLength(),
+        createdAt: Date.now(),
+        lastModified: Date.now()
+      },
+      terms: this.serializeTerms(index),
+      docLengths: this.serializeDocLengths(index)
+    };
+    return data;
+  }
+  /**
+   * Deserialize from object into a new BM25InvertedIndex.
+   */
+  deserialize(data) {
+    if (data.version !== 1) {
+      throw new Error(`Unsupported index version: ${data.version}`);
+    }
+    const index = new BM25InvertedIndex();
+    this.loadIntoIndex(index, data);
+    return index;
+  }
+  serializeTerms(index) {
+    const terms = [];
+    const indexMap = index.index;
+    for (const term of index.getTerms()) {
+      const termInfos = index.getDocumentsForTerm(term);
+      terms.push({
+        term,
+        idf: index.getIDF(term),
+        postings: termInfos.map((info) => ({
+          docId: info.docId,
+          termFrequency: info.termFrequency,
+          positions: info.fieldPositions
+        }))
+      });
+    }
+    return terms;
+  }
+  serializeDocLengths(index) {
+    const lengths = {};
+    for (const [docId, length] of index.getDocLengths()) {
+      lengths[docId] = length;
+    }
+    return lengths;
+  }
+  loadIntoIndex(index, data) {
+    const idx = index;
+    idx.totalDocs = data.metadata.totalDocs;
+    idx.avgDocLength = data.metadata.avgDocLength;
+    idx.docLengths = new Map(Object.entries(data.docLengths));
+    for (const { term, idf, postings } of data.terms) {
+      const termInfos = postings.map((p) => ({
+        docId: p.docId,
+        termFrequency: p.termFrequency,
+        fieldPositions: p.positions
+      }));
+      idx.index.set(term, termInfos);
+      idx.idfCache.set(term, idf);
+      for (const info of termInfos) {
+        if (!idx.docTerms.has(info.docId)) {
+          idx.docTerms.set(info.docId, /* @__PURE__ */ new Set());
+        }
+        idx.docTerms.get(info.docId).add(term);
+      }
+    }
+  }
+};
+
+// src/fts/FullTextIndex.ts
+var FullTextIndex = class {
+  /**
+   * Create a new FullTextIndex.
+   *
+   * @param config - Index configuration
+   */
+  constructor(config) {
+    this.fields = config.fields;
+    this.tokenizer = new BM25Tokenizer(config.tokenizer);
+    this.scorer = new BM25Scorer(config.bm25);
+    this.fieldIndexes = /* @__PURE__ */ new Map();
+    this.combinedIndex = new BM25InvertedIndex();
+    this.indexedDocs = /* @__PURE__ */ new Set();
+    this.serializer = new IndexSerializer();
+    this.documentTokensCache = /* @__PURE__ */ new Map();
+    for (const field of this.fields) {
+      this.fieldIndexes.set(field, new BM25InvertedIndex());
+    }
+  }
+  /**
+   * 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, document) {
+    if (!document || typeof document !== "object") {
+      this.documentTokensCache.delete(docId);
+      return;
+    }
+    if (this.indexedDocs.has(docId)) {
+      this.removeFromIndexes(docId);
+    }
+    const allTokens = [];
+    for (const field of this.fields) {
+      const value = document[field];
+      if (typeof value !== "string") {
+        continue;
+      }
+      const tokens = this.tokenizer.tokenize(value);
+      if (tokens.length > 0) {
+        const fieldIndex = this.fieldIndexes.get(field);
+        fieldIndex.addDocument(docId, tokens);
+        allTokens.push(...tokens);
+      }
+    }
+    if (allTokens.length > 0) {
+      this.combinedIndex.addDocument(docId, allTokens);
+      this.indexedDocs.add(docId);
+      this.documentTokensCache.set(docId, allTokens);
+    } else {
+      this.documentTokensCache.delete(docId);
+    }
+  }
+  /**
+   * Remove a document from the index.
+   * Called when a document is deleted from the CRDT map.
+   *
+   * @param docId - Document identifier to remove
+   */
+  onRemove(docId) {
+    if (!this.indexedDocs.has(docId)) {
+      return;
+    }
+    this.removeFromIndexes(docId);
+    this.indexedDocs.delete(docId);
+    this.documentTokensCache.delete(docId);
+  }
+  /**
+   * 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, options) {
+    const queryTerms = this.tokenizer.tokenize(query);
+    if (queryTerms.length === 0) {
+      return [];
+    }
+    const boost = options?.boost;
+    let results;
+    if (boost && Object.keys(boost).length > 0) {
+      results = this.searchWithBoost(queryTerms, boost);
+    } else {
+      results = this.scorer.score(queryTerms, this.combinedIndex);
+    }
+    if (options?.minScore !== void 0) {
+      results = results.filter((r) => r.score >= options.minScore);
+    }
+    if (options?.limit !== void 0 && options.limit > 0) {
+      results = results.slice(0, options.limit);
+    }
+    return results.map((r) => ({
+      docId: r.docId,
+      score: r.score,
+      matchedTerms: r.matchedTerms,
+      source: "fulltext"
+    }));
+  }
+  /**
+   * Serialize the index state.
+   *
+   * @returns Serialized index data
+   */
+  serialize() {
+    return this.serializer.serialize(this.combinedIndex);
+  }
+  /**
+   * Load index from serialized state.
+   *
+   * @param data - Serialized index data
+   */
+  load(data) {
+    this.combinedIndex = this.serializer.deserialize(data);
+    this.indexedDocs.clear();
+    for (const [docId] of this.combinedIndex.getDocLengths()) {
+      this.indexedDocs.add(docId);
+    }
+    this.fieldIndexes.clear();
+    for (const field of this.fields) {
+      this.fieldIndexes.set(field, new BM25InvertedIndex());
+    }
+    this.documentTokensCache.clear();
+  }
+  /**
+   * Build the index from an array of entries.
+   * Useful for initial bulk loading.
+   *
+   * @param entries - Array of [docId, document] tuples
+   */
+  buildFromEntries(entries) {
+    for (const [docId, document] of entries) {
+      this.onSet(docId, document);
+    }
+  }
+  /**
+   * Clear all data from the index.
+   */
+  clear() {
+    this.combinedIndex.clear();
+    for (const fieldIndex of this.fieldIndexes.values()) {
+      fieldIndex.clear();
+    }
+    this.indexedDocs.clear();
+    this.documentTokensCache.clear();
+  }
+  /**
+   * Get the number of indexed documents.
+   *
+   * @returns Number of documents in the index
+   */
+  getSize() {
+    return this.indexedDocs.size;
+  }
+  /**
+   * 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) {
+    return this.tokenizer.tokenize(query);
+  }
+  /**
+   * 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, queryTerms, document) {
+    if (queryTerms.length === 0) {
+      return null;
+    }
+    let docTokens = this.documentTokensCache.get(docId);
+    if (!docTokens && document) {
+      docTokens = this.tokenizeDocument(document);
+    }
+    if (!docTokens || docTokens.length === 0) {
+      return null;
+    }
+    const docTokenSet = new Set(docTokens);
+    const matchedTerms = queryTerms.filter((term) => docTokenSet.has(term));
+    if (matchedTerms.length === 0) {
+      return null;
+    }
+    const score = this.scorer.scoreSingleDocument(
+      queryTerms,
+      docTokens,
+      this.combinedIndex
+    );
+    if (score <= 0) {
+      return null;
+    }
+    return {
+      docId,
+      score,
+      matchedTerms,
+      source: "fulltext"
+    };
+  }
+  /**
+   * 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
+   */
+  tokenizeDocument(document) {
+    const allTokens = [];
+    for (const field of this.fields) {
+      const value = document[field];
+      if (typeof value === "string") {
+        const tokens = this.tokenizer.tokenize(value);
+        allTokens.push(...tokens);
+      }
+    }
+    return allTokens;
+  }
+  /**
+   * Get the index name (for debugging/display).
+   *
+   * @returns Descriptive name including indexed fields
+   */
+  get name() {
+    return `FullTextIndex(${this.fields.join(", ")})`;
+  }
+  /**
+   * Remove document from all indexes (internal).
+   */
+  removeFromIndexes(docId) {
+    this.combinedIndex.removeDocument(docId);
+    for (const fieldIndex of this.fieldIndexes.values()) {
+      fieldIndex.removeDocument(docId);
+    }
+  }
+  /**
+   * Search with field boosting.
+   * Scores are computed per-field and combined with boost weights.
+   */
+  searchWithBoost(queryTerms, boost) {
+    const docScores = /* @__PURE__ */ new Map();
+    for (const field of this.fields) {
+      const fieldIndex = this.fieldIndexes.get(field);
+      const boostWeight = boost[field] ?? 1;
+      const fieldResults = this.scorer.score(queryTerms, fieldIndex);
+      for (const result of fieldResults) {
+        const current = docScores.get(result.docId) || {
+          score: 0,
+          terms: /* @__PURE__ */ new Set()
+        };
+        current.score += result.score * boostWeight;
+        for (const term of result.matchedTerms) {
+          current.terms.add(term);
+        }
+        docScores.set(result.docId, current);
+      }
+    }
+    const results = [];
+    for (const [docId, { score, terms }] of docScores) {
+      results.push({
+        docId,
+        score,
+        matchedTerms: Array.from(terms)
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+};
+
+// src/IndexedORMap.ts
+var IndexedORMap = class extends ORMap {
+  constructor(hlc, options = {}) {
+    super(hlc);
+    // Full-Text Search (Phase 11)
+    this.fullTextIndex = null;
+    this.options = options;
+    this.indexRegistry = new IndexRegistry();
+    this.queryOptimizer = new QueryOptimizer({
+      indexRegistry: this.indexRegistry
+    });
+    this.indexRegistry.setFallbackIndex(
+      new FallbackIndex(
+        () => this.getAllCompositeKeys(),
+        (compositeKey) => this.getRecordByCompositeKey(compositeKey),
+        (record, query) => this.matchesIndexQuery(record, query)
+      )
+    );
+    this.queryTracker = new QueryPatternTracker();
+    this.indexAdvisor = new IndexAdvisor(this.queryTracker);
+    if (options.adaptiveIndexing?.autoIndex?.enabled) {
+      this.autoIndexManager = new AutoIndexManager(
+        this.queryTracker,
+        this.indexAdvisor,
+        options.adaptiveIndexing.autoIndex
+      );
+      this.autoIndexManager.setMap(this);
+    } else {
+      this.autoIndexManager = null;
+    }
+    if (options.defaultIndexing && options.defaultIndexing !== "none") {
+      this.defaultIndexingStrategy = new DefaultIndexingStrategy(options.defaultIndexing);
+    } else {
+      this.defaultIndexingStrategy = null;
+    }
+  }
+  // ==================== Index Management ====================
+  /**
+   * Add a hash index on an attribute.
+   *
+   * @param attribute - Attribute to index
+   * @returns Created HashIndex
+   */
+  addHashIndex(attribute) {
+    const index = new HashIndex(attribute);
     this.indexRegistry.addIndex(index);
     this.buildIndexFromExisting(index);
     return index;
@@ -8533,6 +10077,104 @@ var IndexedORMap = class extends ORMap {
     this.indexRegistry.addIndex(index);
     this.buildIndexFromExisting(index);
   }
+  // ==================== Full-Text Search (Phase 11) ====================
+  /**
+   * 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) {
+    this.fullTextIndex = new FullTextIndex(config);
+    const snapshot = this.getSnapshot();
+    const entries = [];
+    for (const [key, tagMap] of snapshot.items) {
+      for (const [tag, record] of tagMap) {
+        if (!snapshot.tombstones.has(tag)) {
+          const compositeKey = this.createCompositeKey(key, tag);
+          entries.push([compositeKey, record.value]);
+        }
+      }
+    }
+    this.fullTextIndex.buildFromEntries(entries);
+    return this.fullTextIndex;
+  }
+  /**
+   * Check if full-text search is enabled.
+   *
+   * @returns true if full-text search is enabled
+   */
+  isFullTextSearchEnabled() {
+    return this.fullTextIndex !== null;
+  }
+  /**
+   * Get the full-text index (if enabled).
+   *
+   * @returns The FullTextIndex or null
+   */
+  getFullTextIndex() {
+    return this.fullTextIndex;
+  }
+  /**
+   * 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, options) {
+    if (!this.fullTextIndex) {
+      throw new Error("Full-text search is not enabled. Call enableFullTextSearch() first.");
+    }
+    const scoredDocs = this.fullTextIndex.search(query, options);
+    const results = [];
+    for (const { docId: compositeKey, score, matchedTerms } of scoredDocs) {
+      const [key, tag] = this.parseCompositeKey(compositeKey);
+      const records = this.getRecords(key);
+      const record = records.find((r) => r.tag === tag);
+      if (record) {
+        results.push({
+          key,
+          tag,
+          value: record.value,
+          score,
+          matchedTerms: matchedTerms ?? []
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Disable full-text search and release the index.
+   */
+  disableFullTextSearch() {
+    if (this.fullTextIndex) {
+      this.fullTextIndex.clear();
+      this.fullTextIndex = null;
+    }
+  }
   /**
    * Remove an index.
    *
@@ -8686,6 +10328,9 @@ var IndexedORMap = class extends ORMap {
     const record = super.add(key, value, ttlMs);
     const compositeKey = this.createCompositeKey(key, record.tag);
     this.indexRegistry.onRecordAdded(compositeKey, value);
+    if (this.fullTextIndex) {
+      this.fullTextIndex.onSet(compositeKey, value);
+    }
     return record;
   }
   /**
@@ -8698,6 +10343,9 @@ var IndexedORMap = class extends ORMap {
     for (const record of matchingRecords) {
       const compositeKey = this.createCompositeKey(key, record.tag);
       this.indexRegistry.onRecordRemoved(compositeKey, record.value);
+      if (this.fullTextIndex) {
+        this.fullTextIndex.onRemove(compositeKey);
+      }
     }
     return result;
   }
@@ -8709,6 +10357,9 @@ var IndexedORMap = class extends ORMap {
     if (applied) {
       const compositeKey = this.createCompositeKey(key, record.tag);
       this.indexRegistry.onRecordAdded(compositeKey, record.value);
+      if (this.fullTextIndex) {
+        this.fullTextIndex.onSet(compositeKey, record.value);
+      }
     }
     return applied;
   }
@@ -8731,6 +10382,9 @@ var IndexedORMap = class extends ORMap {
     if (removedValue !== void 0 && removedKey !== void 0) {
       const compositeKey = this.createCompositeKey(removedKey, tag);
       this.indexRegistry.onRecordRemoved(compositeKey, removedValue);
+      if (this.fullTextIndex) {
+        this.fullTextIndex.onRemove(compositeKey);
+      }
     }
   }
   /**
@@ -8739,6 +10393,9 @@ var IndexedORMap = class extends ORMap {
   clear() {
     super.clear();
     this.indexRegistry.clear();
+    if (this.fullTextIndex) {
+      this.fullTextIndex.clear();
+    }
   }
   // ==================== Helper Methods ====================
   /**
@@ -9091,6 +10748,7 @@ var IndexedORMap = class extends ORMap {
 };
 export {
   AuthMessageSchema,
+  BM25Scorer,
   BatchMessageSchema,
   BuiltInProcessors,
   BuiltInResolvers,
@@ -9114,6 +10772,7 @@ export {
   DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_STOP_WORDS,
   DEFAULT_WRITE_CONCERN_TIMEOUT,
+  ENGLISH_STOPWORDS,
   EntryProcessBatchRequestSchema,
   EntryProcessBatchResponseSchema,
   EntryProcessKeyResultSchema,
@@ -9123,8 +10782,11 @@ export {
   EntryProcessorSchema,
   EventJournalImpl,
   FORBIDDEN_PATTERNS,
+  BM25InvertedIndex as FTSInvertedIndex,
+  BM25Tokenizer as FTSTokenizer,
   FallbackIndex,
   FilteringResultSet,
+  FullTextIndex,
   HLC,
   HashIndex,
   IndexRegistry,
@@ -9188,9 +10850,22 @@ export {
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
   RESOLVER_FORBIDDEN_PATTERNS,
+  ReciprocalRankFusion,
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   Ringbuffer,
+  SearchMessageSchema,
+  SearchOptionsSchema,
+  SearchPayloadSchema,
+  SearchRespMessageSchema,
+  SearchRespPayloadSchema,
+  SearchSubMessageSchema,
+  SearchSubPayloadSchema,
+  SearchUnsubMessageSchema,
+  SearchUnsubPayloadSchema,
+  SearchUpdateMessageSchema,
+  SearchUpdatePayloadSchema,
+  SearchUpdateTypeSchema,
   SetResultSet,
   SimpleAttribute,
   SortedMap,
@@ -9236,6 +10911,7 @@ export {
   isUsingNativeHash,
   isWriteConcernAchieved,
   multiAttribute,
+  porterStem,
   resetNativeHash,
   serialize,
   simpleAttribute,