import { g as getBrainAccessor } from './memory-accessor2-BzlgmY-Z.js';
import { t as typedAll } from './typed-query-l1D_QElt.js';
import { Q as QUALITY_SCORE_THRESHOLD } from './quality-scoring-CCPuRQmJ.js';
import { s as searchSimilar } from './brain-similarity-B2HLXCge.js';

//#region ../core/dist/memory/brain-search.js
/**
* Full-text search across BRAIN memory using SQLite FTS5.
* Uses raw SQL via nativeDb because drizzle doesn't support FTS5 virtual tables.
*
* Falls back to LIKE queries if FTS5 is not available (some SQLite builds lack it).
*
* @task T5130
* @epic T5149
*/
/** Track whether FTS5 is available in the current SQLite build. */
var _fts5Available = null;
/** Track whether FTS tables have been created and indexed this session. */
var _fts5Initialized = false;
/**
* Check if FTS5 is available in the current SQLite build.
*/
function checkFts5Available(nativeDb) {
	if (_fts5Available !== null) return _fts5Available;
	try {
		nativeDb.prepare("CREATE VIRTUAL TABLE IF NOT EXISTS _fts5_check USING fts5(test)").run();
		nativeDb.prepare("DROP TABLE IF EXISTS _fts5_check").run();
		_fts5Available = true;
	} catch {
		_fts5Available = false;
	}
	return _fts5Available;
}
/**
* Execute a DDL statement using the native database.
* Wraps nativeDb.prepare().run() for consistent usage.
*/
function execDDL(nativeDb, sql) {
	nativeDb.prepare(sql).run();
}
/**
* Create FTS5 virtual tables and content-sync triggers if they don't exist.
*
* Uses content= to sync from main tables, so inserts to main tables
* auto-populate FTS. UPDATE/DELETE require triggers.
*
* @task T5130
*/
function ensureFts5Tables(nativeDb) {
	if (!checkFts5Available(nativeDb)) return false;
	execDDL(nativeDb, `
    CREATE VIRTUAL TABLE IF NOT EXISTS brain_decisions_fts
    USING fts5(id, decision, rationale, content=brain_decisions, content_rowid=rowid)
  `);
	execDDL(nativeDb, `
    CREATE VIRTUAL TABLE IF NOT EXISTS brain_patterns_fts
    USING fts5(id, pattern, context, content=brain_patterns, content_rowid=rowid)
  `);
	execDDL(nativeDb, `
    CREATE VIRTUAL TABLE IF NOT EXISTS brain_learnings_fts
    USING fts5(id, insight, source, content=brain_learnings, content_rowid=rowid)
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_decisions_ai AFTER INSERT ON brain_decisions BEGIN
      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
      VALUES (new.rowid, new.id, new.decision, new.rationale);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_decisions_ad AFTER DELETE ON brain_decisions BEGIN
      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_decisions_au AFTER UPDATE ON brain_decisions BEGIN
      INSERT INTO brain_decisions_fts(brain_decisions_fts, rowid, id, decision, rationale)
      VALUES('delete', old.rowid, old.id, old.decision, old.rationale);
      INSERT INTO brain_decisions_fts(rowid, id, decision, rationale)
      VALUES (new.rowid, new.id, new.decision, new.rationale);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_patterns_ai AFTER INSERT ON brain_patterns BEGIN
      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
      VALUES (new.rowid, new.id, new.pattern, new.context);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_patterns_ad AFTER DELETE ON brain_patterns BEGIN
      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_patterns_au AFTER UPDATE ON brain_patterns BEGIN
      INSERT INTO brain_patterns_fts(brain_patterns_fts, rowid, id, pattern, context)
      VALUES('delete', old.rowid, old.id, old.pattern, old.context);
      INSERT INTO brain_patterns_fts(rowid, id, pattern, context)
      VALUES (new.rowid, new.id, new.pattern, new.context);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_learnings_ai AFTER INSERT ON brain_learnings BEGIN
      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
      VALUES (new.rowid, new.id, new.insight, new.source);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_learnings_ad AFTER DELETE ON brain_learnings BEGIN
      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
      VALUES('delete', old.rowid, old.id, old.insight, old.source);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_learnings_au AFTER UPDATE ON brain_learnings BEGIN
      INSERT INTO brain_learnings_fts(brain_learnings_fts, rowid, id, insight, source)
      VALUES('delete', old.rowid, old.id, old.insight, old.source);
      INSERT INTO brain_learnings_fts(rowid, id, insight, source)
      VALUES (new.rowid, new.id, new.insight, new.source);
    END
  `);
	execDDL(nativeDb, `
    CREATE VIRTUAL TABLE IF NOT EXISTS brain_observations_fts
    USING fts5(id, title, narrative, content=brain_observations, content_rowid=rowid)
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_observations_ai AFTER INSERT ON brain_observations BEGIN
      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
      VALUES (new.rowid, new.id, new.title, new.narrative);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_observations_ad AFTER DELETE ON brain_observations BEGIN
      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
    END
  `);
	execDDL(nativeDb, `
    CREATE TRIGGER IF NOT EXISTS brain_observations_au AFTER UPDATE ON brain_observations BEGIN
      INSERT INTO brain_observations_fts(brain_observations_fts, rowid, id, title, narrative)
      VALUES('delete', old.rowid, old.id, old.title, old.narrative);
      INSERT INTO brain_observations_fts(rowid, id, title, narrative)
      VALUES (new.rowid, new.id, new.title, new.narrative);
    END
  `);
	return true;
}
/**
* Rebuild FTS5 indexes from the content tables.
* Useful after bulk inserts that bypass triggers.
*
* @task T5130
*/
function rebuildFts5Index(nativeDb) {
	if (!checkFts5Available(nativeDb)) return;
	nativeDb.prepare("INSERT INTO brain_decisions_fts(brain_decisions_fts) VALUES('rebuild')").run();
	nativeDb.prepare("INSERT INTO brain_patterns_fts(brain_patterns_fts) VALUES('rebuild')").run();
	nativeDb.prepare("INSERT INTO brain_learnings_fts(brain_learnings_fts) VALUES('rebuild')").run();
	try {
		nativeDb.prepare("INSERT INTO brain_observations_fts(brain_observations_fts) VALUES('rebuild')").run();
	} catch {}
}
/**
* Unified search across all BRAIN memory tables.
*
* Uses FTS5 MATCH for full-text search with BM25 ranking when available,
* falls back to LIKE queries otherwise.
*
* @task T5130
*/
async function searchBrain(projectRoot, query, options) {
	if (!query?.trim()) return {
		decisions: [],
		patterns: [],
		learnings: [],
		observations: []
	};
	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite-Dg5uGJCo.js');
	await getBrainDb(projectRoot);
	const nativeDb = getBrainNativeDb();
	if (!nativeDb) return {
		decisions: [],
		patterns: [],
		learnings: [],
		observations: []
	};
	const limit = options?.limit ?? 10;
	const tables = options?.tables ?? [
		"decisions",
		"patterns",
		"learnings",
		"observations"
	];
	const peerId = options?.peerId;
	const includeGlobal = options?.includeGlobal ?? true;
	if (ensureFts5Tables(nativeDb)) {
		if (!_fts5Initialized) {
			_fts5Initialized = true;
			rebuildFts5Index(nativeDb);
		}
		return searchWithFts5(nativeDb, query, tables, limit, peerId, includeGlobal);
	}
	return searchWithLike(nativeDb, query, tables, limit, peerId, includeGlobal);
}
/**
* Build a SQL peer isolation clause and the corresponding bind parameters.
*
* When `peerId` is undefined the clause is empty string (no filter applied).
* When `peerId` is provided and `includeGlobal` is true (default), the clause
* is `AND (t.peer_id = ? OR t.peer_id = 'global')`.
* When `includeGlobal` is false, the clause is `AND t.peer_id = ?`.
*
* The `tableAlias` must match the alias used for the main table in the query.
*
* @internal
*/
function buildPeerClause(tableAlias, peerId, includeGlobal) {
	if (!peerId) return {
		clause: "",
		params: []
	};
	if (includeGlobal) return {
		clause: ` AND (${tableAlias}.peer_id = ? OR ${tableAlias}.peer_id = 'global')`,
		params: [peerId]
	};
	return {
		clause: ` AND ${tableAlias}.peer_id = ?`,
		params: [peerId]
	};
}
/**
* Search using FTS5 MATCH with BM25 ranking.
*/
function searchWithFts5(nativeDb, query, tables, limit, peerId, includeGlobal = true) {
	const result = {
		decisions: [],
		patterns: [],
		learnings: [],
		observations: []
	};
	const safeQuery = escapeFts5Query(query);
	if (tables.includes("decisions")) {
		const { clause, params } = buildPeerClause("d", peerId, includeGlobal);
		try {
			result.decisions = typedAll(nativeDb.prepare(`
        SELECT d.*
        FROM brain_decisions_fts fts
        JOIN brain_decisions d ON d.rowid = fts.rowid
        WHERE brain_decisions_fts MATCH ?
          AND (d.quality_score IS NULL OR d.quality_score >= ?)
          ${clause}
        ORDER BY bm25(brain_decisions_fts)
        LIMIT ?
      `), safeQuery, QUALITY_SCORE_THRESHOLD, ...params, limit);
		} catch {
			result.decisions = likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal);
		}
	}
	if (tables.includes("patterns")) {
		const { clause, params } = buildPeerClause("p", peerId, includeGlobal);
		try {
			result.patterns = typedAll(nativeDb.prepare(`
        SELECT p.*
        FROM brain_patterns_fts fts
        JOIN brain_patterns p ON p.rowid = fts.rowid
        WHERE brain_patterns_fts MATCH ?
          AND (p.quality_score IS NULL OR p.quality_score >= ?)
          ${clause}
        ORDER BY bm25(brain_patterns_fts)
        LIMIT ?
      `), safeQuery, QUALITY_SCORE_THRESHOLD, ...params, limit);
		} catch {
			result.patterns = likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal);
		}
	}
	if (tables.includes("learnings")) {
		const { clause, params } = buildPeerClause("l", peerId, includeGlobal);
		try {
			result.learnings = typedAll(nativeDb.prepare(`
        SELECT l.*
        FROM brain_learnings_fts fts
        JOIN brain_learnings l ON l.rowid = fts.rowid
        WHERE brain_learnings_fts MATCH ?
          AND (l.quality_score IS NULL OR l.quality_score >= ?)
          ${clause}
        ORDER BY bm25(brain_learnings_fts)
        LIMIT ?
      `), safeQuery, QUALITY_SCORE_THRESHOLD, ...params, limit);
		} catch {
			result.learnings = likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal);
		}
	}
	if (tables.includes("observations")) {
		const { clause, params } = buildPeerClause("o", peerId, includeGlobal);
		try {
			result.observations = typedAll(nativeDb.prepare(`
        SELECT o.*
        FROM brain_observations_fts fts
        JOIN brain_observations o ON o.rowid = fts.rowid
        WHERE brain_observations_fts MATCH ?
          AND (o.quality_score IS NULL OR o.quality_score >= ?)
          ${clause}
        ORDER BY bm25(brain_observations_fts)
        LIMIT ?
      `), safeQuery, QUALITY_SCORE_THRESHOLD, ...params, limit);
		} catch {
			result.observations = likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal);
		}
	}
	return result;
}
/**
* Search using LIKE queries as fallback when FTS5 is unavailable.
*/
function searchWithLike(nativeDb, query, tables, limit, peerId, includeGlobal = true) {
	const result = {
		decisions: [],
		patterns: [],
		learnings: [],
		observations: []
	};
	if (tables.includes("decisions")) result.decisions = likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal);
	if (tables.includes("patterns")) result.patterns = likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal);
	if (tables.includes("learnings")) result.learnings = likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal);
	if (tables.includes("observations")) result.observations = likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal);
	return result;
}
function likeSearchDecisions(nativeDb, query, limit, peerId, includeGlobal = true) {
	const likePattern = `%${query}%`;
	const { clause, params } = buildPeerClause("brain_decisions", peerId, includeGlobal);
	return typedAll(nativeDb.prepare(`
    SELECT * FROM brain_decisions
    WHERE (decision LIKE ? OR rationale LIKE ?)
      AND (quality_score IS NULL OR quality_score >= ?)
      ${clause}
    ORDER BY created_at DESC
    LIMIT ?
  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
}
function likeSearchPatterns(nativeDb, query, limit, peerId, includeGlobal = true) {
	const likePattern = `%${query}%`;
	const { clause, params } = buildPeerClause("brain_patterns", peerId, includeGlobal);
	return typedAll(nativeDb.prepare(`
    SELECT * FROM brain_patterns
    WHERE (pattern LIKE ? OR context LIKE ?)
      AND (quality_score IS NULL OR quality_score >= ?)
      ${clause}
    ORDER BY frequency DESC
    LIMIT ?
  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
}
function likeSearchLearnings(nativeDb, query, limit, peerId, includeGlobal = true) {
	const likePattern = `%${query}%`;
	const { clause, params } = buildPeerClause("brain_learnings", peerId, includeGlobal);
	return typedAll(nativeDb.prepare(`
    SELECT * FROM brain_learnings
    WHERE (insight LIKE ? OR source LIKE ?)
      AND (quality_score IS NULL OR quality_score >= ?)
      ${clause}
    ORDER BY confidence DESC
    LIMIT ?
  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
}
function likeSearchObservations(nativeDb, query, limit, peerId, includeGlobal = true) {
	const likePattern = `%${query}%`;
	const { clause, params } = buildPeerClause("brain_observations", peerId, includeGlobal);
	return typedAll(nativeDb.prepare(`
    SELECT * FROM brain_observations
    WHERE (title LIKE ? OR narrative LIKE ?)
      AND (quality_score IS NULL OR quality_score >= ?)
      ${clause}
    ORDER BY created_at DESC
    LIMIT ?
  `), likePattern, likePattern, QUALITY_SCORE_THRESHOLD, ...params, limit);
}
/**
* Escape special FTS5 characters in query string.
*
* Wraps each meaningful token in double quotes and joins with OR so that
* partial matches are returned even when some tokens are not indexable
* (e.g. task prefixes like "EPIC:", em-dashes "—", or short stop-words).
*
* Strategy:
*   1. Split on whitespace.
*   2. Keep only tokens that contain at least one word character (\w), which
*      ensures punctuation-only tokens (em dashes, colons standalone, etc.)
*      are dropped before they zero-out the entire result set.
*   3. Deduplicate case-insensitively.
*   4. Join with OR so the query broadens rather than requiring ALL tokens.
*
* Using AND (implicit FTS5 join) caused empty results whenever a task title
* contained non-word tokens such as em dashes ("—") or trailing colons
* ("EPIC:"), because FTS5's default tokenizer cannot index them and the
* AND semantics then guaranteed zero matches for the whole query. (T553 bug fix)
*/
function escapeFts5Query(query) {
	const rawTokens = query.trim().split(/\s+/).filter(Boolean);
	if (rawTokens.length === 0) return "\"\"";
	const seen = /* @__PURE__ */ new Set();
	const tokens = [];
	for (const t of rawTokens) {
		const stripped = t.replace(/^\W+|\W+$/g, "");
		if (stripped.length < 2) continue;
		if (!/\w/.test(stripped)) continue;
		const lower = stripped.toLowerCase();
		if (seen.has(lower)) continue;
		seen.add(lower);
		tokens.push(`"${stripped.replace(/"/g, "\"\"")}"`);
	}
	if (tokens.length === 0) return "\"\"";
	return tokens.join(" OR ");
}
/**
* Fuse ranked lists from multiple retrieval sources using Reciprocal Rank Fusion.
*
* Implements the RRF algorithm from Cormack, Clarke & Buettcher (SIGIR 2009):
*
*   score(d) = Σ 1 / (k + rank(d, list))  for each list containing d
*
* where k=60 is the research-proven smoothing constant.
*
* Properties:
* - Rank-based: actual scores from each source are ignored (only rank matters).
* - Additive: items appearing in multiple lists accumulate higher scores.
* - Robust: the +60 constant prevents rank-1 items from dominating.
*
* @param sources - Named arrays of ranked hits (order = rank, index 0 = best)
* @param k - RRF smoothing constant (default: RRF_K = 60)
* @returns Array of fused results sorted by rrfScore descending
*
* @example
* ```ts
* const fused = reciprocalRankFusion([
*   { source: 'fts', hits: ftsHits },
*   { source: 'vec', hits: vecHits },
* ]);
* ```
*/
function reciprocalRankFusion(sources, k = 60) {
	const accum = /* @__PURE__ */ new Map();
	for (const { source, hits } of sources) for (let rank = 0; rank < hits.length; rank++) {
		const hit = hits[rank];
		const contribution = 1 / (k + rank);
		const existing = accum.get(hit.id);
		if (existing) {
			existing.rrfScore += contribution;
			existing.sources.add(source);
			if (source === "fts") existing.ftsRank = rank;
			if (source === "vec") existing.vecRank = rank;
		} else accum.set(hit.id, {
			rrfScore: contribution,
			type: hit.type,
			title: hit.title,
			text: hit.text,
			sources: new Set([source]),
			ftsRank: source === "fts" ? rank : void 0,
			vecRank: source === "vec" ? rank : void 0
		});
	}
	return [...accum.entries()].map(([id, data]) => ({
		id,
		rrfScore: data.rrfScore,
		type: data.type,
		title: data.title,
		text: data.text,
		sources: [...data.sources],
		ftsRank: data.ftsRank,
		vecRank: data.vecRank
	})).sort((a, b) => b.rrfScore - a.rrfScore);
}
/**
* Hybrid search across FTS5, vector similarity, graph neighbors, and optionally code symbols.
* Uses Reciprocal Rank Fusion (RRF) for result combination.
*
* Algorithm:
* 1. Run FTS5 search, vector similarity search, and optionally code symbol search in parallel.
* 2. Optionally expand via graph neighbors (best-effort).
* 3. Fuse all ranked lists with RRF: score = Σ 1/(rank+rrfK).
* 4. Return top-N sorted by fused RRF score.
*
* Graceful degradation: vector, graph, and code sources are silently skipped when
* unavailable — RRF naturally handles partial source lists.
*
* @param query - Search query text
* @param projectRoot - Project root directory
* @param options - Limit, RRF tuning, and includeCode flag for code symbol search
* @returns Array of hybrid results ranked by RRF score descending
*
* @task T5130 (hybrid search), T1058 (code symbol integration)
*/
async function hybridSearch(query, projectRoot, options) {
	if (!query?.trim()) return [];
	const maxResults = options?.limit ?? 10;
	const rrfK = options?.rrfK ?? 60;
	const includeCode = options?.includeCode ?? false;
	const searches = [searchBrain(projectRoot, query, { limit: maxResults * 3 }).catch(() => ({
		decisions: [],
		patterns: [],
		learnings: [],
		observations: []
	})), searchSimilar(query, projectRoot, maxResults * 3).catch(() => [])];
	let codeSearchPromise = null;
	if (includeCode) {
		codeSearchPromise = (async () => {
			try {
				const { smartSearch } = await import('./src4-d9ULsE_o.js');
				return smartSearch(query, {
					maxResults: maxResults * 2,
					rootDir: projectRoot
				}).map((r) => ({
					id: `code:${r.symbol.filePath}:${r.symbol.name}:${r.symbol.startLine}`,
					title: r.symbol.name,
					kind: r.symbol.kind,
					score: r.score
				}));
			} catch {
				return [];
			}
		})();
		searches.push(codeSearchPromise);
	}
	const allResults = await Promise.all(searches);
	const ftsResults = allResults[0];
	const vecResults = allResults[1];
	const codeResults = includeCode ? allResults[2] ?? [] : [];
	const ftsHits = [];
	for (const d of ftsResults.decisions) ftsHits.push({
		id: d.id,
		type: "decision",
		title: d.decision,
		text: `${d.decision} — ${d.rationale}`
	});
	for (const p of ftsResults.patterns) ftsHits.push({
		id: p.id,
		type: "pattern",
		title: p.pattern,
		text: `${p.pattern} — ${p.context}`
	});
	for (const l of ftsResults.learnings) ftsHits.push({
		id: l.id,
		type: "learning",
		title: l.insight,
		text: `${l.insight} (source: ${l.source})`
	});
	for (const o of ftsResults.observations) ftsHits.push({
		id: o.id,
		type: "observation",
		title: o.title,
		text: o.narrative ?? o.title
	});
	const vecHits = vecResults.map((r) => ({
		id: r.id,
		type: r.type,
		title: r.title,
		text: r.text
	}));
	const codeHits = codeResults.map((r) => ({
		id: r.id,
		type: "code-symbol",
		title: r.title,
		text: `${r.title} (${r.kind})`
	}));
	const rrfSources = [];
	if (ftsHits.length > 0) rrfSources.push({
		source: "fts",
		hits: ftsHits
	});
	if (vecHits.length > 0) rrfSources.push({
		source: "vec",
		hits: vecHits
	});
	if (codeHits.length > 0) rrfSources.push({
		source: "code",
		hits: codeHits
	});
	try {
		const accessor = await getBrainAccessor(projectRoot);
		const possibleNodeIds = [
			`concept:${query.toLowerCase().replace(/\s+/g, "-")}`,
			`task:${query}`,
			`doc:${query}`
		];
		const graphHits = [];
		for (const nodeId of possibleNodeIds) {
			if (!await accessor.getPageNode(nodeId)) continue;
			const neighbors = await accessor.getNeighbors(nodeId);
			for (const neighbor of neighbors) graphHits.push({
				id: neighbor.id,
				type: neighbor.nodeType,
				title: neighbor.label,
				text: neighbor.label
			});
		}
		if (graphHits.length > 0) rrfSources.push({
			source: "graph",
			hits: graphHits
		});
	} catch {}
	return reciprocalRankFusion(rrfSources, rrfK).slice(0, maxResults).map((r) => ({
		id: r.id,
		score: r.rrfScore,
		type: r.type,
		title: r.title,
		text: r.text,
		sources: r.sources,
		ftsRank: r.ftsRank,
		vecRank: r.vecRank
	}));
}

export { ensureFts5Tables as e, hybridSearch as h, searchBrain as s };
//# sourceMappingURL=brain-search2-tm7GcSB8.js.map
