@teammates/recall 0.4.1 → 0.5.1

package/dist/query-expansion.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { buildQueryVariations, extractKeywords } from "./query-expansion.js";
+describe("extractKeywords", () => {
+    it("removes stopwords", () => {
+        const result = extractKeywords("the quick brown fox jumps over the lazy dog");
+        expect(result).toContain("quick");
+        expect(result).toContain("brown");
+        expect(result).toContain("fox");
+        expect(result).toContain("jumps");
+        expect(result).toContain("lazy");
+        expect(result).toContain("dog");
+        expect(result).not.toContain("the");
+        expect(result).not.toContain("over");
+    });
+    it("filters short tokens (length <= 2)", () => {
+        const result = extractKeywords("an AI is a type of ML system");
+        expect(result).not.toContain("an");
+        expect(result).not.toContain("is");
+        // "type" and "system" stay, "AI" and "ML" filtered (length 2)
+        expect(result).toContain("type");
+        expect(result).toContain("system");
+    });
+    it("deduplicates while preserving order", () => {
+        const result = extractKeywords("recall search recall index search");
+        expect(result).toEqual(["recall", "search", "index"]);
+    });
+    it("lowercases all output", () => {
+        const result = extractKeywords("Update the HOOKS spec");
+        expect(result).toContain("update");
+        expect(result).toContain("hooks");
+        expect(result).toContain("spec");
+    });
+    it("returns empty array for all-stopword input", () => {
+        const result = extractKeywords("the is a");
+        expect(result).toEqual([]);
+    });
+    it("preserves @mentions and paths", () => {
+        const result = extractKeywords("deploy @pipeline src/hooks");
+        expect(result).toContain("deploy");
+        expect(result).toContain("@pipeline");
+        expect(result).toContain("src/hooks");
+    });
+});
+describe("buildQueryVariations", () => {
+    it("always includes the original prompt as the first query", () => {
+        const result = buildQueryVariations("fix the authentication bug");
+        expect(result[0]).toBe("fix the authentication bug");
+    });
+    it("generates a keyword-focused query when prompt is verbose", () => {
+        const verbose = "I want you to please update the recall search system so that it handles multiple queries at the same time and deduplicates the results properly";
+        const result = buildQueryVariations(verbose);
+        expect(result.length).toBeGreaterThanOrEqual(2);
+        // The keyword query should be shorter than the original
+        if (result.length > 1) {
+            expect(result[1].length).toBeLessThan(verbose.length);
+        }
+    });
+    it("adds a conversation-derived query when context is provided", () => {
+        const conversationContext = `## Conversation History
+
+**stevenic:** lets talk about the CI pipeline and hooks
+
+**pipeline:** CI Pipeline Hooks — Analysis`;
+        const result = buildQueryVariations("what should we do next?", conversationContext);
+        // Should have at least the original + conversation query
+        expect(result.length).toBeGreaterThanOrEqual(2);
+    });
+    it("skips conversation query when no context", () => {
+        const result = buildQueryVariations("short task");
+        // Short prompts with few keywords may only produce 1 query
+        expect(result.length).toBeGreaterThanOrEqual(1);
+        expect(result[0]).toBe("short task");
+    });
+    it("does not generate keyword query when prompt is already concise", () => {
+        const result = buildQueryVariations("recall search");
+        // Very short — keyword query wouldn't differ meaningfully
+        expect(result[0]).toBe("recall search");
+    });
+});

package/dist/search.d.ts

@@ -18,6 +18,13 @@ export interface SearchOptions {
     /** Relevance boost multiplier for typed memories over episodic summaries (default: 1.2) */
     typedMemoryBoost?: number;
 }
+/** Options for multi-query search with deduplication. */
+export interface MultiSearchOptions extends SearchOptions {
+    /** Additional queries beyond the primary (keyword-focused, conversation-derived, etc.) */
+    additionalQueries?: string[];
+    /** Pre-matched memory catalog results to merge into the final set */
+    catalogMatches?: SearchResult[];
+}
 export interface SearchResult {
     teammate: string;
     uri: string;
@@ -26,6 +33,10 @@ export interface SearchResult {
     /** Content type: "typed_memory", "weekly", "monthly", or "other" */
     contentType?: string;
 }
+/**
+ * Classify a URI into a content type for priority scoring.
+ */
+export declare function classifyUri(uri: string): string;
 /**
  * Search teammate memories using multi-pass retrieval.
  *
@@ -34,3 +45,12 @@ export interface SearchResult {
  * Results are merged, deduped, and typed memories get a relevance boost.
  */
 export declare function search(query: string, options: SearchOptions): Promise<SearchResult[]>;
+/**
+ * Multi-query search with deduplication and catalog merge.
+ *
+ * Fires the primary query plus any additional queries (keyword-focused,
+ * conversation-derived) and merges results. Catalog matches (from frontmatter
+ * text matching) are also merged. Deduplication is by URI — when the same
+ * URI appears from multiple queries, the highest score wins.
+ */
+export declare function multiSearch(primaryQuery: string, options: MultiSearchOptions): Promise<SearchResult[]>;

package/dist/search.js

@@ -6,7 +6,7 @@ import { Indexer } from "./indexer.js";
 /**
  * Classify a URI into a content type for priority scoring.
  */
-function classifyUri(uri) {
+export function classifyUri(uri) {
     if (uri.includes("/memory/weekly/"))
         return "weekly";
     if (uri.includes("/memory/monthly/"))
@@ -132,3 +132,52 @@ export async function search(query, options) {
     allResults.sort((a, b) => b.score - a.score);
     return allResults.slice(0, maxResults + recencyDepth); // allow extra slots for recency results
 }
+/**
+ * Multi-query search with deduplication and catalog merge.
+ *
+ * Fires the primary query plus any additional queries (keyword-focused,
+ * conversation-derived) and merges results. Catalog matches (from frontmatter
+ * text matching) are also merged. Deduplication is by URI — when the same
+ * URI appears from multiple queries, the highest score wins.
+ */
+export async function multiSearch(primaryQuery, options) {
+    const additionalQueries = options.additionalQueries ?? [];
+    const catalogMatches = options.catalogMatches ?? [];
+    const maxResults = options.maxResults ?? 5;
+    const recencyDepth = options.recencyDepth ?? 2;
+    // Fire all queries — primary gets full treatment (recency pass + semantic)
+    // Additional queries get semantic only (skipRecency to avoid duplicate weeklies)
+    const primaryResults = await search(primaryQuery, options);
+    // Collect all results keyed by URI, keeping highest score
+    const bestByUri = new Map();
+    for (const r of primaryResults) {
+        const existing = bestByUri.get(r.uri);
+        if (!existing || r.score > existing.score) {
+            bestByUri.set(r.uri, r);
+        }
+    }
+    // Fire additional queries (reuse same search options minus recency to avoid dupes)
+    for (const query of additionalQueries) {
+        const results = await search(query, {
+            ...options,
+            recencyDepth: 0, // primary already got the weekly summaries
+        });
+        for (const r of results) {
+            const existing = bestByUri.get(r.uri);
+            if (!existing || r.score > existing.score) {
+                bestByUri.set(r.uri, r);
+            }
+        }
+    }
+    // Merge catalog matches (frontmatter text-matched results)
+    for (const r of catalogMatches) {
+        const existing = bestByUri.get(r.uri);
+        if (!existing || r.score > existing.score) {
+            bestByUri.set(r.uri, r);
+        }
+    }
+    // Sort by score descending, return top results
+    const merged = [...bestByUri.values()];
+    merged.sort((a, b) => b.score - a.score);
+    return merged.slice(0, maxResults + recencyDepth);
+}

package/dist/search.test.js

@@ -1,23 +1,46 @@
-import { describe, expect, it } from "vitest";
-// classifyUri is not exported, so we test it indirectly via a re-implementation
-// or we can import the module and test the search function behavior.
-// Since classifyUri is a pure function, let's extract and test its logic.
-describe("classifyUri", () => {
-    // Re-implement the classification logic for unit testing
-    function classifyUri(uri) {
-        if (uri.includes("/memory/weekly/"))
-            return "weekly";
-        if (uri.includes("/memory/monthly/"))
-            return "monthly";
-        const memoryMatch = uri.match(/\/memory\/([^/]+)\.md$/);
-        if (memoryMatch) {
-            const stem = memoryMatch[1];
-            if (/^\d{4}-\d{2}-\d{2}$/.test(stem))
-                return "daily";
-            return "typed_memory";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Indexer } from "./indexer.js";
+import { classifyUri, multiSearch, search } from "./search.js";
+// Deterministic stub embeddings based on text content
+function stubCreateEmbeddings(inputs) {
+    const texts = Array.isArray(inputs) ? inputs : [inputs];
+    return {
+        status: "success",
+        output: texts.map((t) => {
+            const vec = new Array(384).fill(0);
+            for (let i = 0; i < t.length; i++) {
+                vec[i % 384] += t.charCodeAt(i) / 1000;
+            }
+            return vec;
+        }),
+    };
+}
+// Mock LocalEmbeddings so search() uses stubs instead of real model
+vi.mock("./embeddings.js", () => ({
+    LocalEmbeddings: class {
+        maxTokens = 256;
+        async createEmbeddings(inputs) {
+            return stubCreateEmbeddings(inputs);
         }
-        return "other";
-    }
+    },
+}));
+function createIndexer(teammatesDir) {
+    const indexer = new Indexer({ teammatesDir });
+    // Indexer also creates LocalEmbeddings internally — already mocked above
+    return indexer;
+}
+let testDir;
+beforeEach(async () => {
+    testDir = join(tmpdir(), `recall-search-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(testDir, { recursive: true });
+});
+afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+});
+describe("classifyUri", () => {
     it("classifies weekly summaries", () => {
         expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
     });
@@ -40,3 +63,224 @@ describe("classifyUri", () => {
         expect(classifyUri("beacon/notes/todo.md")).toBe("other");
     });
 });
+describe("search", () => {
+    it("returns results from an indexed teammate", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom about coding");
+        await writeFile(join(memDir, "feedback_testing.md"), "# Testing feedback\nAlways run tests before committing.");
+        // Pre-build the index with stub embeddings
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        // Patch search to use stub embeddings by searching with skipSync
+        const results = await search("testing feedback", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            model: "stub", // won't matter since we mock at the index level
+        });
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].teammate).toBe("beacon");
+        expect(results[0].score).toBeGreaterThan(0);
+    });
+    it("returns empty results when no index exists", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+        });
+        expect(results).toEqual([]);
+    });
+    it("includes recent weekly summaries via recency pass", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W10.md"), "# Week 10\nWorked on search.");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nWorked on indexer.");
+        await writeFile(join(weeklyDir, "2026-W09.md"), "# Week 9\nOld stuff.");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+        });
+        const uris = results.map((r) => r.uri);
+        // Should include the 2 most recent weeks (W11 and W10), not W09
+        expect(uris).toContain("beacon/memory/weekly/2026-W11.md");
+        expect(uris).toContain("beacon/memory/weekly/2026-W10.md");
+        expect(uris).not.toContain("beacon/memory/weekly/2026-W09.md");
+    });
+    it("respects recencyDepth: 0 (no weekly summaries)", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nContent here.");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 0,
+        });
+        const uris = results.map((r) => r.uri);
+        expect(uris).not.toContain("beacon/memory/weekly/2026-W11.md");
+    });
+    it("searches all teammates when no teammate specified", async () => {
+        const beacon = join(testDir, "beacon");
+        const scribe = join(testDir, "scribe");
+        await mkdir(join(beacon, "memory"), { recursive: true });
+        await mkdir(join(scribe, "memory"), { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(scribe, "SOUL.md"), "# Scribe");
+        await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom");
+        await writeFile(join(scribe, "WISDOM.md"), "# Scribe wisdom");
+        // Build indexes
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        await indexer.indexTeammate("scribe");
+        const results = await search("wisdom", {
+            teammatesDir: testDir,
+            skipSync: true,
+        });
+        const teammates = new Set(results.map((r) => r.teammate));
+        expect(teammates.size).toBeGreaterThanOrEqual(1);
+    });
+    it("deduplicates recency results with semantic results", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nSearch implementation details.");
+        // Build index that includes the weekly file
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await search("search implementation", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+        });
+        // The weekly file should appear only once despite being picked up by both passes
+        const weeklyUris = results.filter((r) => r.uri === "beacon/memory/weekly/2026-W11.md");
+        expect(weeklyUris).toHaveLength(1);
+    });
+    it("applies typed memory boost", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Some wisdom about testing");
+        await writeFile(join(memDir, "feedback_testing.md"), "# Testing feedback\nAlways verify test output carefully.");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await search("testing", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            typedMemoryBoost: 1.5,
+        });
+        // Find typed memory results — they should have boosted scores
+        const typedResults = results.filter((r) => r.contentType === "typed_memory");
+        if (typedResults.length > 0) {
+            // Just verify the contentType was set correctly
+            expect(typedResults[0].contentType).toBe("typed_memory");
+        }
+    });
+});
+describe("multiSearch", () => {
+    it("merges results from primary and additional queries", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about architecture");
+        await writeFile(join(memDir, "feedback_code_review.md"), "# Code review feedback\nAlways review pull requests thoroughly.");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await multiSearch("architecture", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            additionalQueries: ["code review"],
+        });
+        expect(results.length).toBeGreaterThan(0);
+    });
+    it("deduplicates by URI — highest score wins", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about testing and code quality");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await multiSearch("testing", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            additionalQueries: ["testing code quality"],
+        });
+        // Check no duplicate URIs
+        const uris = results.map((r) => r.uri);
+        const uniqueUris = new Set(uris);
+        expect(uris.length).toBe(uniqueUris.size);
+    });
+    it("merges catalog matches into results", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const catalogMatches = [
+            {
+                teammate: "beacon",
+                uri: "beacon/memory/project_goals.md",
+                text: "# Project Goals\nBuild the best recall system.",
+                score: 0.92,
+                contentType: "typed_memory",
+            },
+        ];
+        const results = await multiSearch("goals", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            catalogMatches,
+        });
+        const goalResult = results.find((r) => r.uri === "beacon/memory/project_goals.md");
+        expect(goalResult).toBeDefined();
+        expect(goalResult.score).toBe(0.92);
+    });
+    it("additional queries skip recency pass (recencyDepth: 0)", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nDid some work.");
+        const results = await multiSearch("work", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+            additionalQueries: ["more work"],
+        });
+        // Weekly should appear at most once (from primary, not duplicated from additional)
+        const weeklyResults = results.filter((r) => r.uri === "beacon/memory/weekly/2026-W11.md");
+        expect(weeklyResults.length).toBeLessThanOrEqual(1);
+    });
+    it("returns empty when no index and no catalog matches", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        const results = await multiSearch("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+        });
+        expect(results).toEqual([]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/recall",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Local semantic memory search for teammates. Indexes WISDOM.md and memory files using Vectra + transformers.js.",
   "type": "module",
   "main": "dist/index.js",

package/src/embeddings.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi } from "vitest";
+import { LocalEmbeddings } from "./embeddings.js";
+
+// Mock @huggingface/transformers to avoid loading the real model
+vi.mock("@huggingface/transformers", () => ({
+  pipeline: vi.fn(async () => {
+    // Return a fake extractor function
+    return async (texts: string[], _opts: any) => ({
+      tolist: () => texts.map(() => new Array(384).fill(0.1)),
+    });
+  }),
+}));
+
+describe("LocalEmbeddings", () => {
+  it("has maxTokens set to 256", () => {
+    const emb = new LocalEmbeddings();
+    expect(emb.maxTokens).toBe(256);
+  });
+
+  describe("createEmbeddings", () => {
+    it("returns embeddings for a single string input", async () => {
+      const emb = new LocalEmbeddings();
+      const result = await emb.createEmbeddings("hello world");
+
+      expect(result.status).toBe("success");
+      expect(result.output).toHaveLength(1);
+      expect(result.output![0]).toHaveLength(384);
+    });
+
+    it("returns embeddings for an array of strings", async () => {
+      const emb = new LocalEmbeddings();
+      const result = await emb.createEmbeddings(["hello", "world"]);
+
+      expect(result.status).toBe("success");
+      expect(result.output).toHaveLength(2);
+      expect(result.output![0]).toHaveLength(384);
+      expect(result.output![1]).toHaveLength(384);
+    });
+
+    it("returns empty output for empty string input", async () => {
+      const emb = new LocalEmbeddings();
+      const result = await emb.createEmbeddings("");
+
+      expect(result.status).toBe("success");
+      expect(result.output).toHaveLength(0);
+    });
+
+    it("returns empty output for whitespace-only input", async () => {
+      const emb = new LocalEmbeddings();
+      const result = await emb.createEmbeddings("   ");
+
+      expect(result.status).toBe("success");
+      expect(result.output).toHaveLength(0);
+    });
+
+    it("filters out empty strings from array input", async () => {
+      const emb = new LocalEmbeddings();
+      const result = await emb.createEmbeddings(["hello", "", "  ", "world"]);
+
+      expect(result.status).toBe("success");
+      expect(result.output).toHaveLength(2);
+    });
+
+    it("returns error status when extractor throws", async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      // Override mock to throw
+      (pipeline as any).mockImplementationOnce(async () => {
+        return async () => {
+          throw new Error("Model load failed");
+        };
+      });
+
+      const emb = new LocalEmbeddings("bad-model");
+      const result = await emb.createEmbeddings("test");
+
+      expect(result.status).toBe("error");
+      expect(result.message).toBe("Model load failed");
+    });
+
+    it("reuses the extractor on subsequent calls (lazy init)", async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      (pipeline as any).mockClear();
+
+      const emb = new LocalEmbeddings();
+      await emb.createEmbeddings("first");
+      await emb.createEmbeddings("second");
+
+      // pipeline() should only be called once (lazy singleton)
+      expect(pipeline).toHaveBeenCalledTimes(1);
+    });
+
+    it("accepts a custom model name", async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      (pipeline as any).mockClear();
+
+      const emb = new LocalEmbeddings("custom/model-name");
+      await emb.createEmbeddings("test");
+
+      expect(pipeline).toHaveBeenCalledWith(
+        "feature-extraction",
+        "custom/model-name",
+        expect.objectContaining({ dtype: "fp32" }),
+      );
+    });
+  });
+});

package/src/index.ts

@@ -1,3 +1,11 @@
 export { LocalEmbeddings } from "./embeddings.js";
 export { Indexer, type IndexerConfig } from "./indexer.js";
-export { type SearchOptions, type SearchResult, search } from "./search.js";
+export { matchMemoryCatalog, scanMemoryCatalog } from "./memory-index.js";
+export { buildQueryVariations, extractKeywords } from "./query-expansion.js";
+export {
+  type MultiSearchOptions,
+  type SearchOptions,
+  type SearchResult,
+  multiSearch,
+  search,
+} from "./search.js";