@ohos-cpf/3rdloop 0.0.8 → 0.0.10

package/vendor/Archive/src/search/catalog-routing.js

@@ -0,0 +1,87 @@
+/**
+ * catalog-routing.js — 目录权重路由
+ *
+ * 根据查询特征（API 符号、中文/英文混合、"如何/步骤"等）
+ * 动态计算各目录的搜索 boost 倍数。
+ */
+
+/**
+ * @typedef {Object} CatalogBoostResult
+ * @property {number} catalogId
+ * @property {number} boost
+ */
+
+/**
+ * 计算目录 boost。
+ * 规则：
+ *   - @ohos. 查询 → references ×1.5
+ *   - "如何/步骤" 查询 → guides ×1.45
+ *   - 中文+英文API混合 → guides ×1.45 + references ×1.35
+ *
+ * @param {string} query         规范化后的查询
+ * @param {string[]} tokens      分词后的 token
+ * @param {Map<string, {id:string,title:string,searchBoost?:number,tailInGlobalSearch?:boolean}>} catalogMap
+ * @param {function(string):number} catalogToId 将 catalog id 转为数字 ID
+ * @returns {Map<number, number>} catalogId → boost 倍数
+ */
+export function computeCatalogBoosts(query, tokens, catalogMap, catalogToId) {
+  /** @type {Map<number, number>} */
+  const boosts = new Map();
+
+  // 初始化：所有目录使用配置的 searchBoost（默认 1.0）
+  for (const config of catalogMap.values()) {
+    boosts.set(catalogToId(config.id), config.searchBoost ?? 1.0);
+  }
+
+  const hasOhosModule = /@[a-z]+\.[a-z]/i.test(query);
+  const hasHowTo = /如何|怎么|步骤|教程|入门|guide/i.test(query);
+  const hasChinese = /[\u4e00-\u9fa5]/.test(query);
+  const hasEnglishApi = tokens.some((t) => /^[A-Z][a-zA-Z0-9]+|@[a-z]+\.[a-z]/i.test(t));
+
+  if (hasOhosModule) {
+    applyBoost(boosts, catalogMap, catalogToId, 'references', 1.5);
+  }
+
+  if (hasHowTo) {
+    applyBoost(boosts, catalogMap, catalogToId, 'guides', 1.45);
+  }
+
+  if (hasChinese && hasEnglishApi) {
+    applyBoost(boosts, catalogMap, catalogToId, 'guides', 1.45);
+    applyBoost(boosts, catalogMap, catalogToId, 'references', 1.35);
+  }
+
+  return boosts;
+}
+
+/**
+ * 应用 boost（取较大值，不覆盖更高的已有 boost）。
+ * @param {Map<number, number>} boosts
+ * @param {Map<string, any>} catalogMap
+ * @param {function(string):number} catalogToId
+ * @param {string} catalogId
+ * @param {number} value
+ */
+function applyBoost(boosts, catalogMap, catalogToId, catalogId, value) {
+  if (!catalogMap.has(catalogId)) return;
+  const numId = catalogToId(catalogId);
+  const current = boosts.get(numId) ?? 1.0;
+  boosts.set(numId, Math.max(current, value));
+}
+
+/**
+ * 获取全局搜索时排到尾部的目录 ID 集合。
+ * @param {Map<string, any>} catalogMap
+ * @param {function(string):number} catalogToId
+ * @returns {Set<number>}
+ */
+export function getTailCatalogIds(catalogMap, catalogToId) {
+  /** @type {Set<number>} */
+  const tail = new Set();
+  for (const config of catalogMap.values()) {
+    if (config.tailInGlobalSearch) {
+      tail.add(catalogToId(config.id));
+    }
+  }
+  return tail;
+}

package/vendor/Archive/src/search/fts-search.js

@@ -0,0 +1,289 @@
+/**
+ * fts-search.js — FTS5 查询执行 + Rerank 重排序
+ *
+ * 职责：
+ *   1. 执行 FTS5 MATCH 查询，获取 BM25 排序结果。
+ *   2. 多层 boost 调整：
+ *      - 目录权重（catalogBoost）
+ *      - 标题匹配 boost（精确/前缀/全分词包含）
+ *      - API 符号匹配 boost（Manager API 强提升）
+ *   3. 同文档多段去重（只保留最佳段）。
+ *   4. AND/OR 回退策略。
+ *
+ * 查询使用只读内存 DB（反序列化），高性能无磁盘 I/O。
+ */
+
+import { RERANK_POOL_FACTOR } from '../constants.js';
+import {
+  buildFtsOrMatch,
+  buildFtsAndMatch,
+} from './query-normalizer.js';
+import { extractSnippet } from './snippet.js';
+import { matchApiSymbol } from '../parser/api-identifiers.js';
+import { isManagerApi } from '../parser/api-suffixes.js';
+import {
+  computeCatalogBoosts,
+  getTailCatalogIds,
+} from './catalog-routing.js';
+
+/**
+ * @typedef {import('../types.js').SearchResult} SearchResult
+ */
+
+/**
+ * FTS5 查询基础 SQL（全局）。
+ */
+const FTS_SEARCH_SQL = `
+SELECT
+  d.document_id,
+  d.doc_title,
+  s.section_title,
+  s.lead_text,
+  s.excerpt_truncated,
+  d.catalog_id,
+  s.id AS segment_id,
+  bm25(segments_fts) AS bm25
+FROM segments_fts
+JOIN segments s ON s.id = segments_fts.rowid
+JOIN documents d ON d.id = s.doc_id
+WHERE segments_fts MATCH ?
+ORDER BY bm25(segments_fts)
+LIMIT ?;
+`;
+
+/**
+ * FTS5 查询基础 SQL（目录限定）。
+ */
+const FTS_SEARCH_CATALOG_SQL = `
+SELECT
+  d.document_id,
+  d.doc_title,
+  s.section_title,
+  s.lead_text,
+  s.excerpt_truncated,
+  d.catalog_id,
+  s.id AS segment_id,
+  bm25(segments_fts) AS bm25
+FROM segments_fts
+JOIN segments s ON s.id = segments_fts.rowid
+JOIN documents d ON d.id = s.doc_id
+WHERE segments_fts MATCH ? AND d.catalog_id = ?
+ORDER BY bm25(segments_fts)
+LIMIT ?;
+`;
+
+export default class FtsSearch {
+  /**
+   * @param {import('../db/sqlite-backend.js').default} backend
+   * @param {string} dbPath
+   * @param {Map<string, any>} catalogMap
+   * @param {function(string):number} catalogToId
+   * @param {function(number):string} idToCatalog
+   */
+  constructor(backend, dbPath, catalogMap, catalogToId, idToCatalog) {
+    this.backend = backend;
+    this.dbPath = dbPath;
+    this.catalogMap = catalogMap;
+    this.catalogToId = catalogToId;
+    this.idToCatalog = idToCatalog;
+  }
+
+  /**
+   * 执行搜索（含 AND/OR 回退 + Rerank + 去重）。
+   * @param {{rawQuery:string, tokens:string[], preferAnd:boolean, ftsMatch:string|null}} prepared
+   * @param {{catalog?:string, limit?:number, includeSnippet?:boolean, snippetMaxChars?:number}} query
+   * @param {string[]} [apiSymbols] 当前段 API 符号（可选，用于 boost）
+   * @returns {Promise<SearchResult[]>}
+   */
+  async search(prepared, query) {
+    if (!prepared.tokens || prepared.tokens.length === 0) return [];
+
+    const limit = query.limit || 10;
+    const poolSize = limit * RERANK_POOL_FACTOR;
+    const catalogId = query.catalog ? this.catalogToId(query.catalog) : undefined;
+
+    // AND/OR 回退策略
+    let rows = [];
+    if (prepared.preferAnd) {
+      const andMatch = buildFtsAndMatch(prepared.tokens);
+      const andRows = await this.runMatch(andMatch, catalogId, poolSize);
+      if (andRows.length >= limit) {
+        rows = andRows;
+      } else {
+        // 不足 limit，用 OR 补全
+        const orMatch = buildFtsOrMatch(prepared.tokens);
+        const orRows = await this.runMatch(orMatch, catalogId, poolSize);
+        rows = mergeAndDedupe(andRows, orRows, poolSize);
+      }
+    } else {
+      const match = prepared.ftsMatch || buildFtsOrMatch(prepared.tokens);
+      rows = await this.runMatch(match, catalogId, poolSize);
+    }
+
+    // Rerank
+    const reranked = this.rerank(rows, prepared);
+
+    // 同文档去重
+    const deduped = pickBestSegmentForDocument(reranked);
+
+    // 截取 limit
+    const topResults = deduped.slice(0, limit);
+
+    // 转换为 SearchResult
+    const includeSnippet = query.includeSnippet !== false;
+    const snippetMaxChars = query.snippetMaxChars || 200;
+
+    return topResults.map((row) => ({
+      documentId: row.document_id,
+      title: row.doc_title,
+      sectionTitle: row.section_title || row.doc_title,
+      snippet: includeSnippet
+        ? extractSnippet(row.lead_text || '', prepared.rawQuery, snippetMaxChars)
+        : '',
+      score: row.effectiveScore,
+      rawScore: row.bm25,
+      catalog: this.idToCatalog(row.catalog_id),
+    }));
+  }
+
+  /**
+   * 执行一次 FTS MATCH 查询。
+   * @param {string} matchExpr FTS MATCH 表达式
+   * @param {number|undefined} catalogId 目录限定
+   * @param {number} limit
+   * @returns {Promise<any[]>}
+   */
+  async runMatch(matchExpr, catalogId, limit) {
+    if (!matchExpr) return [];
+    const db = await this.backend.openReadDb(this.dbPath);
+
+    let stmt;
+    if (catalogId !== undefined) {
+      stmt = db.prepare(FTS_SEARCH_CATALOG_SQL);
+      stmt.bind([matchExpr, catalogId, limit]);
+    } else {
+      stmt = db.prepare(FTS_SEARCH_SQL);
+      stmt.bind([matchExpr, limit]);
+    }
+
+    /** @type {any[]} */
+    const rows = [];
+    while (stmt.step()) {
+      rows.push(stmt.get());
+    }
+    stmt.finalize();
+    return rows;
+  }
+
+  /**
+   * Rerank：多层 boost 调整 effectiveScore。
+   * @param {any[]} rows
+   * @param {{rawQuery:string, tokens:string[]}} prepared
+   * @returns {any[]}
+   */
+  rerank(rows, prepared) {
+    const boosts = computeCatalogBoosts(
+      prepared.rawQuery,
+      prepared.tokens,
+      this.catalogMap,
+      this.catalogToId
+    );
+    const tailIds = getTailCatalogIds(this.catalogMap, this.catalogToId);
+
+    for (const row of rows) {
+      const catalogBoost = boosts.get(row.catalog_id) ?? 1.0;
+      const tailPenalty = tailIds.has(row.catalog_id) ? 1.2 : 1.0;
+
+      // baseScore: BM25 除以目录 boost（boost 越大分数越小 = 更靠前）
+      const baseScore = (row.bm25 || 0) / catalogBoost * tailPenalty;
+
+      // titleBoost
+      const titleLower = (row.section_title || row.doc_title || '').toLowerCase();
+      let titleMultiplier = 1.0;
+      const queryLower = prepared.rawQuery.toLowerCase();
+      if (titleLower === queryLower) {
+        titleMultiplier = 4.0;
+      } else if (titleLower.startsWith(queryLower.slice(0, 6)) && queryLower.length >= 6) {
+        titleMultiplier = 1.8;
+      } else {
+        // 标题包含所有分词
+        const allInTitle = prepared.tokens.every((t) => titleLower.includes(t.toLowerCase()));
+        if (allInTitle) titleMultiplier = 1.35;
+      }
+
+      // apiSymbolBoost: 判断标题是否含 Manager API
+      let apiMultiplier = 1.0;
+      if (isManagerApi(row.section_title || '')) {
+        apiMultiplier = 3.5;
+        if (this.idToCatalog(row.catalog_id) === 'references') {
+          apiMultiplier *= 1.4;
+        }
+      } else {
+        // 检查 token 是否匹配 API 符号
+        const symbols = [row.section_title, row.doc_title].filter(Boolean);
+        const anyMatch = prepared.tokens.some((t) => matchApiSymbol(t, symbols));
+        if (anyMatch) apiMultiplier = 1.5;
+      }
+
+      row.effectiveScore = baseScore / (titleMultiplier * apiMultiplier);
+      row.rawScore = row.bm25;
+    }
+
+    // 按 effectiveScore 升序（越小越相关）
+    rows.sort((a, b) => a.effectiveScore - b.effectiveScore);
+    return rows;
+  }
+}
+
+/**
+ * AND + OR 结果合并去重。
+ * @param {any[]} andRows
+ * @param {any[]} orRows
+ * @param {number} limit
+ * @returns {any[]}
+ */
+function mergeAndDedupe(andRows, orRows, limit) {
+  /** @type {Set<string>} */
+  const seen = new Set();
+  /** @type {any[]} */
+  const result = [];
+  for (const row of andRows) {
+    const key = `${row.document_id}:${row.segment_id}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(row);
+    }
+  }
+  for (const row of orRows) {
+    const key = `${row.document_id}:${row.segment_id}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(row);
+    }
+    if (result.length >= limit) break;
+  }
+  return result;
+}
+
+/**
+ * 同文档多段去重：只保留最佳段。
+ * @param {any[]} rows 已按 effectiveScore 排序
+ * @returns {any[]}
+ */
+function pickBestSegmentForDocument(rows) {
+  /** @type {Map<string, any>} */
+  const bestByDoc = new Map();
+  /** @type {any[]} */
+  const ordered = [];
+
+  for (const row of rows) {
+    const docId = row.document_id;
+    if (!bestByDoc.has(docId)) {
+      bestByDoc.set(docId, row);
+      ordered.push(row);
+    }
+    // 已有该文档的段，跳过（保留第一个 = 最佳）
+  }
+
+  return ordered;
+}

package/vendor/Archive/src/search/query-normalizer.js

@@ -0,0 +1,159 @@
+/**
+ * query-normalizer.js — 查询预处理
+ *
+ * 对用户输入的原始查询进行规范化：
+ *   - 合并多余空白、截断超长查询。
+ *   - 识别特殊查询模式（API 短语拆分、单个 API 符号）。
+ *   - 与 jieba 分词 + 同义词扩展协同产出 FTS token。
+ */
+
+import { QUERY_MAX_RAW_CHARS, QUERY_MAX_FTS_TOKENS, QUERY_AND_MAX_TOKENS } from '../constants.js';
+
+/**
+ * @typedef {Object} PreparedQuery
+ * @property {string} rawQuery         原始查询
+ * @property {string} expandedQuery    同义词扩展后的查询
+ * @property {string[]} tokens         FTS token 列表
+ * @property {boolean} preferAnd       是否优先 AND 匹配
+ * @property {string|null} ftsMatch    预构建的 FTS MATCH 表达式
+ */
+
+/**
+ * 规范化搜索输入：合并空格 + 截断。
+ * @param {string} raw
+ * @returns {string}
+ */
+export function normalizeSearchInput(raw) {
+  if (!raw) return '';
+  return raw.replace(/\s+/g, ' ').trim().slice(0, QUERY_MAX_RAW_CHARS);
+}
+
+/**
+ * 判断是否为单个 API 模块符号（如 @ohos.camera）。
+ * @param {string} query
+ * @returns {boolean}
+ */
+function isSingleApiSymbol(query) {
+  return /^@[a-z]+\.[a-z][a-zA-Z0-9.]*$/i.test(query.trim());
+}
+
+/**
+ * 检测 API 短语拆分场景（如 "camera manager"）。
+ * @param {string} query
+ * @returns {{left:string, right:string}|null}
+ */
+function detectSplitApiPhrase(query) {
+  const parts = query.trim().split(/\s+/);
+  if (parts.length === 2) {
+    // 形如 "camera manager" → left=camera, right=manager
+    if (/^[a-z]/i.test(parts[0]) && /^[a-z]/i.test(parts[1])) {
+      return { left: parts[0], right: parts[1] };
+    }
+  }
+  return null;
+}
+
+/**
+ * 预处理查询，产出 PreparedQuery。
+ *
+ * @param {string} rawQuery       用户原始查询
+ * @param {import('../tokenizer/tokenizer.js').default} tokenizer
+ * @param {import('../tokenizer/lexicon.js').default} lexicon
+ * @param {{expandSynonyms?:boolean, synonymExpandLimit?:number, preferAnd?:boolean}} [options]
+ * @returns {Promise<PreparedQuery>}
+ */
+export async function prepareQuery(rawQuery, tokenizer, lexicon, options = {}) {
+  const normalized = normalizeSearchInput(rawQuery);
+  if (!normalized) {
+    return { rawQuery: '', expandedQuery: '', tokens: [], preferAnd: false, ftsMatch: null };
+  }
+
+  const expandSynonyms = options.expandSynonyms !== false;
+  const synonymLimit = options.synonymExpandLimit || 8;
+
+  // 同义词扩展
+  const expandedQuery = expandSynonyms
+    ? lexicon.expandSynonyms(normalized, synonymLimit)
+    : normalized;
+
+  // jieba 分词（查询模式）
+  let tokens = await tokenizer.tokenizeForQuery(expandedQuery);
+
+  // 特殊查询模式处理
+  let ftsMatch = null;
+
+  if (isSingleApiSymbol(normalized)) {
+    // 单个 API 符号：OR 匹配变体
+    const variants = await tokenizer.tokenizeForQuery(normalized);
+    tokens = dedupe([...tokens, ...variants]).slice(0, QUERY_MAX_FTS_TOKENS);
+    ftsMatch = buildFtsOrMatch(tokens);
+  } else {
+    const split = detectSplitApiPhrase(normalized);
+    if (split) {
+      const leftTokens = await tokenizer.tokenizeForQuery(split.left);
+      const rightTokens = await tokenizer.tokenizeForQuery(split.right);
+      ftsMatch = buildSplitApiAndMatch(leftTokens, rightTokens);
+    }
+  }
+
+  // 限制 token 数量
+  tokens = tokens.slice(0, QUERY_MAX_FTS_TOKENS);
+
+  // 策略选择：2-4 个 token → preferAnd
+  let preferAnd = options.preferAnd;
+  if (preferAnd === undefined) {
+    preferAnd = tokens.length >= 2 && tokens.length <= QUERY_AND_MAX_TOKENS;
+  }
+
+  return { rawQuery: normalized, expandedQuery, tokens, preferAnd, ftsMatch };
+}
+
+/**
+ * 去重。
+ * @param {string[]} arr
+ * @returns {string[]}
+ */
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+
+/**
+ * FTS5 token 转义（防注入）。
+ * @param {string} token
+ * @returns {string}
+ */
+export function escapeFtsToken(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+
+/**
+ * 构建 OR 匹配表达式。
+ * @param {string[]} tokens
+ * @returns {string}
+ */
+export function buildFtsOrMatch(tokens) {
+  const filtered = tokens.filter(Boolean);
+  if (filtered.length === 0) return '';
+  return filtered.map(escapeFtsToken).join(' OR ');
+}
+
+/**
+ * 构建 AND 匹配表达式。
+ * @param {string[]} tokens
+ * @returns {string}
+ */
+export function buildFtsAndMatch(tokens) {
+  const filtered = tokens.filter(Boolean);
+  if (filtered.length === 0) return '';
+  return filtered.map(escapeFtsToken).join(' AND ');
+}
+
+/**
+ * 构建拆分 API 的 AND 匹配。
+ * @param {string[]} left
+ * @param {string[]} right
+ * @returns {string}
+ */
+function buildSplitApiAndMatch(left, right) {
+  return `(${buildFtsOrMatch(left)}) AND (${buildFtsOrMatch(right)})`;
+}

package/vendor/Archive/src/search/query-rewriter.js

@@ -0,0 +1,72 @@
+/**
+ * query-rewriter.js — 查询重写器
+ *
+ * 封装同义词扩展的动态注册能力：
+ *   - 运行时注册自定义同义词组。
+ *   - 与 Lexicon 的文件词典合并，不影响磁盘词典。
+ *
+ * 通过内存同义词组叠加到 Lexicon 的 getSynonymMap() 之上，
+ * 避免频繁修改磁盘文件。
+ */
+
+export default class QueryRewriter {
+  constructor() {
+    /** @type {string[][]} */
+    this.customGroups = [];
+  }
+
+  /**
+   * 注册自定义同义词组。
+   * @param {string[]} words
+   */
+  addSynonyms(words) {
+    if (Array.isArray(words) && words.length >= 2) {
+      this.customGroups.push([...words]);
+    }
+  }
+
+  /**
+   * 将自定义同义词组合并进 Lexicon 的同义词映射。
+   * @param {import('../tokenizer/lexicon.js').default} lexicon
+   * @returns {Map<string, Set<string>>}
+   */
+  mergeWithLexicon(lexicon) {
+    const map = new Map(lexicon.getSynonymMap());
+    for (const group of this.customGroups) {
+      for (const word of group) {
+        const key = word.toLowerCase();
+        if (!map.has(key)) map.set(key, new Set());
+        for (const other of group) {
+          if (other !== word) map.get(key).add(other);
+        }
+      }
+    }
+    return map;
+  }
+
+  /**
+   * 扩展查询（使用合并后的同义词映射）。
+   * @param {string} query
+   * @param {import('../tokenizer/lexicon.js').default} lexicon
+   * @param {number} [maxParts=8]
+   * @returns {string}
+   */
+  expand(query, lexicon, maxParts = 8) {
+    const map = this.mergeWithLexicon(lexicon);
+    const parts = query.split(/\s+/).filter(Boolean);
+    /** @type {Set<string>} */
+    const expanded = new Set();
+
+    for (let i = 0; i < parts.length && expanded.size < maxParts; i++) {
+      expanded.add(parts[i]);
+      const syns = map.get(parts[i].toLowerCase());
+      if (syns) {
+        for (const s of syns) {
+          if (expanded.size >= maxParts) break;
+          expanded.add(s);
+        }
+      }
+    }
+    return [...expanded].join(' ');
+  }
+}

package/vendor/Archive/src/search/search-engine.js

@@ -0,0 +1,72 @@
+/**
+ * search-engine.js — 搜索调度层
+ *
+ * 编排查询预处理 → FTS5 检索 → Rerank → 摘要提取的完整管道。
+ * 作为 IndexManager/Engine 与底层 FtsSearch 之间的中间层，
+ * 隔离查询逻辑与索引写入逻辑。
+ */
+
+import { prepareQuery } from './query-normalizer.js';
+import FtsSearch from './fts-search.js';
+
+export default class SearchEngine {
+  /**
+   * @param {import('../db/sqlite-backend.js').default} backend
+   * @param {import('../tokenizer/tokenizer.js').default} tokenizer
+   * @param {import('../tokenizer/lexicon.js').default} lexicon
+   * @param {string} dbPath
+   * @param {Map<string, any>} catalogMap
+   * @param {function(string):number} catalogToId
+   * @param {function(number):string} idToCatalog
+   * @param {import('./query-rewriter.js').default} [rewriter]
+   */
+  constructor(backend, tokenizer, lexicon, dbPath, catalogMap, catalogToId, idToCatalog, rewriter) {
+    this.backend = backend;
+    this.tokenizer = tokenizer;
+    this.lexicon = lexicon;
+    this.dbPath = dbPath;
+    this.catalogMap = catalogMap;
+    this.catalogToId = catalogToId;
+    this.idToCatalog = idToCatalog;
+    this.rewriter = rewriter || null;
+
+    this.fts = new FtsSearch(backend, dbPath, catalogMap, catalogToId, idToCatalog);
+  }
+
+  /**
+   * 执行搜索。
+   * @param {import('../types.js').SearchQuery} query
+   * @param {import('../types.js').SearchOptions} [options]
+   * @returns {Promise<import('../types.js').SearchResult[]>}
+   */
+  async search(query, options = {}) {
+    if (!query.query || !query.query.trim()) return [];
+
+    // 如果有自定义重写器，先扩展同义词
+    let effectiveQuery = query.query;
+    if (this.rewriter && options.expandSynonyms !== false) {
+      effectiveQuery = this.rewriter.expand(
+        query.query,
+        this.lexicon,
+        options.synonymExpandLimit
+      );
+    }
+
+    // 查询预处理
+    const prepared = await prepareQuery(
+      effectiveQuery,
+      this.tokenizer,
+      this.lexicon,
+      {
+        expandSynonyms: options.expandSynonyms,
+        synonymExpandLimit: options.synonymExpandLimit,
+        preferAnd: options.preferAnd,
+      }
+    );
+
+    if (!prepared.tokens || prepared.tokens.length === 0) return [];
+
+    // FTS5 检索 + Rerank
+    return this.fts.search(prepared, query);
+  }
+}