@agent-native/core 0.137.7 → 0.138.0

package/dist/scripts/docs/framework-search.js

@@ -0,0 +1,239 @@
+/**
+ * Core script: framework-search
+ *
+ * Search the version-matched framework docs and readable source together.
+ * This is intentionally bounded and read-only so every app chat can use the
+ * same fallback when a question is not answered by the docs alone.
+ */
+import fs from "node:fs";
+import { createTextMatcher, } from "../../search-utils/index.js";
+import { parseArgs } from "../utils.js";
+import { loadAllDocs } from "./search.js";
+import { listSourceFiles } from "./source-search.js";
+const DEFAULT_LIMIT = 30;
+const MAX_LIMIT = 50;
+const MAX_SNIPPETS_PER_RESULT = 3;
+function parseScope(value) {
+    if (!value)
+        return { value: "all" };
+    if (value === "all" || value === "docs" || value === "source") {
+        return { value };
+    }
+    return { error: `Invalid scope "${value}". Use all, docs, or source.` };
+}
+function parseMode(value) {
+    if (!value)
+        return { value: "substring" };
+    if (value === "substring" ||
+        value === "glob" ||
+        value === "sql-like" ||
+        value === "regex") {
+        return { value };
+    }
+    return {
+        error: `Invalid mode "${value}". Use substring, glob, sql-like, or regex.`,
+    };
+}
+function parseLimit(value) {
+    if (!value)
+        return { value: DEFAULT_LIMIT };
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        return { error: "Limit must be a positive integer." };
+    }
+    return { value: Math.min(parsed, MAX_LIMIT) };
+}
+function docsAsEntries(docs) {
+    return docs.map((doc) => ({
+        kind: "doc",
+        path: `docs/${doc.slug}`,
+        title: doc.title,
+        body: `${doc.title}\n${doc.description}\n${doc.body}`,
+    }));
+}
+function sourceAsEntries(files) {
+    const entries = [];
+    let unreadable = 0;
+    for (const file of files) {
+        try {
+            entries.push({
+                kind: "source",
+                path: file.relativePath,
+                body: fs.readFileSync(file.absolutePath, "utf-8"),
+                file,
+            });
+        }
+        catch {
+            unreadable += 1;
+        }
+    }
+    return { entries, unreadable };
+}
+function snippetsForEntry(entry, matcher, pathMatch) {
+    const snippets = [];
+    const lines = entry.body.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        if (!matcher.matches(lines[index]))
+            continue;
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        snippets.push(`${index + 1}: ${line.slice(0, 260)}`);
+        if (snippets.length >= MAX_SNIPPETS_PER_RESULT)
+            break;
+    }
+    if (snippets.length === 0 && pathMatch) {
+        const firstLine = lines.find((line) => line.trim());
+        if (firstLine)
+            snippets.push(`1: ${firstLine.trim().slice(0, 260)}`);
+    }
+    return snippets;
+}
+function pathMatches(path, filter) {
+    if (!filter)
+        return { matches: true };
+    const matcher = createTextMatcher(filter, "glob");
+    return { matches: matcher.matches(path), error: matcher.error };
+}
+async function searchFramework(options) {
+    const [docs, sourceResult] = await Promise.all([
+        options.scope === "source" ? Promise.resolve([]) : loadAllDocs(),
+        options.scope === "docs"
+            ? Promise.resolve({ entries: [], unreadable: 0 })
+            : Promise.resolve(sourceAsEntries(listSourceFiles())),
+    ]);
+    const entries = [
+        ...(options.scope === "source" ? [] : docsAsEntries(docs)),
+        ...(options.scope === "docs" ? [] : sourceResult.entries),
+    ];
+    const matcher = createTextMatcher(options.pattern, options.mode);
+    if (matcher.error) {
+        return { hits: [], total: 0, unreadable: 0 };
+    }
+    const hits = [];
+    for (const entry of entries) {
+        const pathResult = pathMatches(entry.path, options.pathFilter);
+        if (pathResult.error)
+            continue;
+        if (!pathResult.matches)
+            continue;
+        const pathMatch = matcher.matches(entry.path);
+        const contentMatch = matcher.matches(entry.body);
+        if (!pathMatch && !contentMatch)
+            continue;
+        const snippets = snippetsForEntry(entry, matcher, pathMatch);
+        hits.push({ entry, pathMatch, snippets });
+    }
+    // Keep the result deterministic and favor docs titles and exact path hits.
+    hits.sort((a, b) => {
+        const aScore = (a.pathMatch ? 2 : 0) + (a.entry.kind === "doc" ? 1 : 0);
+        const bScore = (b.pathMatch ? 2 : 0) + (b.entry.kind === "doc" ? 1 : 0);
+        return bScore - aScore || a.entry.path.localeCompare(b.entry.path);
+    });
+    return {
+        hits: hits.slice(0, options.limit),
+        total: hits.length,
+        unreadable: sourceResult.unreadable,
+    };
+}
+function printHelp() {
+    console.log(`Usage: pnpm action framework-search [options]
+
+Options:
+  --pattern <text>   Text, wildcard, SQL-like, or regex pattern to search
+  --query <text>     Alias for --pattern
+  --scope <scope>    all, docs, or source (default: all)
+  --mode <mode>      substring, glob, sql-like, or regex (default: substring)
+  --path <glob>      Optional glob to limit matching paths
+  --limit <number>   Maximum files to return (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT})
+  --list             List the searchable docs and source roots
+  --help             Show this help message`);
+}
+export default async function frameworkSearchScript(args) {
+    const parsed = parseArgs(args);
+    if (parsed.help === "true") {
+        printHelp();
+        return;
+    }
+    const scopeResult = parseScope(parsed.scope);
+    if (scopeResult.error) {
+        console.log(scopeResult.error);
+        return;
+    }
+    const scope = scopeResult.value;
+    const modeResult = parseMode(parsed.mode);
+    if (modeResult.error) {
+        console.log(modeResult.error);
+        return;
+    }
+    const mode = modeResult.value;
+    const limitResult = parseLimit(parsed.limit);
+    if (limitResult.error) {
+        console.log(limitResult.error);
+        return;
+    }
+    const limit = limitResult.value;
+    if (parsed.list === "true") {
+        const [docs, sourceFiles] = await Promise.all([
+            scope === "source" ? Promise.resolve([]) : loadAllDocs(),
+            scope === "docs"
+                ? Promise.resolve([])
+                : Promise.resolve(listSourceFiles()),
+        ]);
+        console.log(JSON.stringify({
+            docs: docs.map((doc) => ({ slug: doc.slug, title: doc.title })),
+            source: {
+                files: sourceFiles.length,
+                roots: Array.from(new Set(sourceFiles.map((file) => file.relativePath.split("/")[0]))),
+            },
+        }, null, 2));
+        return;
+    }
+    const pattern = parsed.pattern ?? parsed.query;
+    if (!pattern) {
+        printHelp();
+        return;
+    }
+    const matcher = createTextMatcher(pattern, mode);
+    if (matcher.error) {
+        console.log(matcher.error);
+        return;
+    }
+    if (parsed.path) {
+        const pathMatcher = createTextMatcher(parsed.path, "glob");
+        if (pathMatcher.error) {
+            console.log(pathMatcher.error);
+            return;
+        }
+    }
+    const result = await searchFramework({
+        pattern,
+        mode,
+        scope,
+        pathFilter: parsed.path,
+        limit,
+    });
+    if (result.total === 0) {
+        console.log(`No matches in the indexed ${scope} corpus for ${JSON.stringify(pattern)}.`);
+        console.log("The search covers version-matched framework docs, runtime-visible skills, and readable Core, Toolkit, and first-party template source. A miss is not proof that an implementation is absent if the relevant package source is not published in this app.");
+        if (result.unreadable > 0) {
+            console.log(`Skipped ${result.unreadable} unreadable source file(s).`);
+        }
+        return;
+    }
+    console.log(`Found ${result.total} matching file(s) in ${scope} using ${mode} mode for ${JSON.stringify(pattern)}:\n`);
+    for (const hit of result.hits) {
+        const label = hit.entry.kind === "doc" ? "doc" : "source";
+        console.log(`[${label}] ${hit.entry.path}${hit.entry.title ? ` - ${hit.entry.title}` : ""}`);
+        for (const snippet of hit.snippets)
+            console.log(`  ${snippet}`);
+        console.log("");
+    }
+    if (result.total > result.hits.length) {
+        console.log(`Showing ${result.hits.length} of ${result.total} matching files. Refine --path, --pattern, or --limit for more targeted evidence.`);
+    }
+    if (result.unreadable > 0) {
+        console.log(`Skipped ${result.unreadable} unreadable source file(s).`);
+    }
+}
+//# sourceMappingURL=framework-search.js.map

package/dist/scripts/docs/index.js

@@ -1,4 +1,5 @@
 export const coreDocsScripts = {
+    "framework-search": (args) => import("./framework-search.js").then((m) => m.default(args)),
     "docs-search": (args) => import("./search.js").then((m) => m.default(args)),
     "source-search": (args) => import("./source-search.js").then((m) => m.default(args)),
 };

package/dist/scripts/docs/search.d.ts

@@ -9,5 +9,15 @@
  *   pnpm action docs-search --slug authentication
  *   pnpm action docs-search --list
  */
+interface DocMeta {
+    slug: string;
+    title: string;
+    description: string;
+}
+export interface DocFull extends DocMeta {
+    body: string;
+}
+export declare function loadAllDocs(): Promise<DocFull[]>;
 export default function docsSearchScript(args: string[]): Promise<void>;
+export {};
 //# sourceMappingURL=search.d.ts.map

package/dist/scripts/docs/search.js

@@ -164,7 +164,7 @@ async function loadAgentBundleDocs() {
         return [];
     }
 }
-async function loadAllDocs() {
+export async function loadAllDocs() {
     return [...loadFilesystemDocs(), ...(await loadAgentBundleDocs())];
 }
 async function searchDocs(query) {

package/dist/scripts/docs/source-search.d.ts

@@ -1,15 +1,22 @@
 /**
  * Core script: source-search
  *
- * Search and read the packaged Agent Native first-party template corpus.
- * The corpus is generated into @agent-native/core/corpus during package build.
+ * Search and read version-matched framework source.
+ * First-party templates are generated into @agent-native/core/corpus during
+ * package build; Core and Toolkit source are read from their installed roots.
  *
  * Usage:
  *   pnpm action source-search --query "defineAction"
  *   pnpm action source-search --path templates/chat/actions/hello.ts
+ *   pnpm action source-search --path core/src/action.ts
  *   pnpm action source-search --path templates/plan/AGENTS.md
  *   pnpm action source-search --list
  */
+export interface SourceFile {
+    relativePath: string;
+    absolutePath: string;
+    visibilityRoot?: string;
+}
 /**
  * The corpus is a sibling of the package root, so a bundled serverless deploy
  * never carries it. Callers register this tool conditionally: advertising a
@@ -17,5 +24,6 @@
  * and reads to it like the code genuinely does not exist.
  */
 export declare function hasSourceCorpus(): boolean;
+export declare function listSourceFiles(): SourceFile[];
 export default function sourceSearchScript(args: string[]): Promise<void>;
 //# sourceMappingURL=source-search.d.ts.map

package/dist/scripts/docs/source-search.js

@@ -1,12 +1,14 @@
 /**
  * Core script: source-search
  *
- * Search and read the packaged Agent Native first-party template corpus.
- * The corpus is generated into @agent-native/core/corpus during package build.
+ * Search and read version-matched framework source.
+ * First-party templates are generated into @agent-native/core/corpus during
+ * package build; Core and Toolkit source are read from their installed roots.
  *
  * Usage:
  *   pnpm action source-search --query "defineAction"
  *   pnpm action source-search --path templates/chat/actions/hello.ts
+ *   pnpm action source-search --path core/src/action.ts
  *   pnpm action source-search --path templates/plan/AGENTS.md
  *   pnpm action source-search --list
  */
@@ -57,6 +59,40 @@ function getCorpusRoot() {
     //   dist/scripts/docs/source-search.js -> corpus/
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../corpus");
 }
+function getPackageRoot() {
+    return path.dirname(getCorpusRoot());
+}
+function getToolkitSourceRoot() {
+    const candidates = [
+        path.resolve(getPackageRoot(), "../toolkit/src"),
+        path.resolve(process.cwd(), "node_modules/@agent-native/toolkit/src"),
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+function getSourceRoots() {
+    const corpusRoot = getCorpusRoot();
+    const roots = [
+        {
+            prefix: "templates",
+            directory: path.join(corpusRoot, "templates"),
+            visibilityRoot: corpusRoot,
+        },
+    ];
+    // A monorepo checkout has the authored Core source. Published packages do
+    // not carry the whole source tree, so use their readable dist output.
+    const coreSourceRoot = path.join(getPackageRoot(), "src");
+    roots.push(fs.existsSync(path.join(coreSourceRoot, "server"))
+        ? { prefix: "core/src", directory: coreSourceRoot }
+        : { prefix: "core/dist", directory: path.join(getPackageRoot(), "dist") });
+    const toolkitSourceRoot = getToolkitSourceRoot();
+    if (toolkitSourceRoot) {
+        roots.push({
+            prefix: "toolkit/src",
+            directory: toolkitSourceRoot,
+        });
+    }
+    return roots;
+}
 /**
  * The corpus is a sibling of the package root, so a bundled serverless deploy
  * never carries it. Callers register this tool conditionally: advertising a
@@ -125,29 +161,52 @@ function isRuntimeVisibleCorpusPath(corpusRoot, absolutePath) {
         return true;
     }
 }
-function listFiles(dir, base = dir, corpusRoot = getCorpusRoot()) {
+function listFiles(dir, base = dir, visibilityRoot) {
     if (!fs.existsSync(dir))
         return [];
     const files = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
         const abs = path.join(dir, entry.name);
-        if (!isRuntimeVisibleCorpusPath(corpusRoot, abs))
+        if (visibilityRoot && !isRuntimeVisibleCorpusPath(visibilityRoot, abs)) {
             continue;
+        }
         if (entry.isDirectory()) {
-            files.push(...listFiles(abs, base, corpusRoot));
+            files.push(...listFiles(abs, base, visibilityRoot));
         }
         else if (entry.isFile() && isProbablyTextFile(abs)) {
-            const stat = fs.statSync(abs);
+            let stat;
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch {
+                continue;
+            }
             if (stat.size <= MAX_FILE_BYTES) {
                 files.push({
                     absolutePath: abs,
                     relativePath: path.relative(base, abs).split(path.sep).join("/"),
+                    visibilityRoot,
                 });
             }
         }
     }
     return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
+export function listSourceFiles() {
+    return getSourceRoots()
+        .flatMap((root) => listFiles(root.directory, root.directory, root.visibilityRoot).map((file) => ({
+        ...file,
+        relativePath: `${root.prefix}/${file.relativePath}`,
+    })))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
 function lineSnippet(line, terms) {
     const trimmed = line.trim();
     if (trimmed.length <= 220)
@@ -162,7 +221,6 @@ function lineSnippet(line, terms) {
     return `${start > 0 ? "..." : ""}${trimmed.slice(start, end)}${end < trimmed.length ? "..." : ""}`;
 }
 function searchCorpus(query) {
-    const corpusRoot = getCorpusRoot();
     const terms = query
         .toLowerCase()
         .split(/\s+/)
@@ -171,7 +229,9 @@ function searchCorpus(query) {
     if (terms.length === 0)
         return [];
     const results = [];
-    for (const file of listFiles(corpusRoot)) {
+    for (const file of listSourceFiles()) {
+        if (/\.(?:spec|test)\.[cm]?[jt]sx?$/.test(file.relativePath))
+            continue;
         let raw = "";
         try {
             raw = fs.readFileSync(file.absolutePath, "utf-8");
@@ -204,26 +264,37 @@ function searchCorpus(query) {
     }
     return results.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
 }
-function readCorpusPath(relative) {
+function readSourcePath(relative) {
     if (!isValidPath(relative)) {
-        return `Invalid corpus path: ${relative}`;
+        return `Invalid source path: ${relative}`;
     }
-    const corpusRoot = getCorpusRoot();
-    const target = path.resolve(corpusRoot, relative);
-    if (!target.startsWith(corpusRoot + path.sep) && target !== corpusRoot) {
-        return `Invalid corpus path: ${relative}`;
+    const sourceRoot = getSourceRoots().find((root) => relative === root.prefix || relative.startsWith(`${root.prefix}/`));
+    if (!sourceRoot)
+        return `Source path not found: ${relative}`;
+    const rootRelativePath = relative
+        .slice(sourceRoot.prefix.length)
+        .replace(/^\//, "");
+    const target = path.resolve(sourceRoot.directory, rootRelativePath);
+    if (!target.startsWith(sourceRoot.directory + path.sep) &&
+        target !== sourceRoot.directory) {
+        return `Invalid source path: ${relative}`;
     }
     if (!fs.existsSync(target)) {
-        return `Corpus path not found: ${relative}`;
+        return `Source path not found: ${relative}`;
     }
-    if (!isRuntimeVisibleCorpusPath(corpusRoot, target)) {
-        return `Corpus path is not available to runtime source-search: ${relative}`;
+    if (sourceRoot.visibilityRoot &&
+        !isRuntimeVisibleCorpusPath(sourceRoot.visibilityRoot, target)) {
+        return `Source path is not available to runtime source-search: ${relative}`;
     }
     const stat = fs.statSync(target);
     if (stat.isDirectory()) {
         const entries = fs
             .readdirSync(target, { withFileTypes: true })
-            .filter((entry) => isRuntimeVisibleCorpusPath(corpusRoot, path.join(target, entry.name)))
+            .filter((entry) => {
+            if (!sourceRoot.visibilityRoot)
+                return true;
+            return isRuntimeVisibleCorpusPath(sourceRoot.visibilityRoot, path.join(target, entry.name));
+        })
             .map((entry) => `${entry.isDirectory() ? "dir " : "file"} ${entry.name}`)
             .sort();
         const shown = entries.slice(0, 200);
@@ -239,33 +310,30 @@ function readCorpusPath(relative) {
             .join("\n");
     }
     if (!stat.isFile())
-        return `Unsupported corpus path: ${relative}`;
+        return `Unsupported source path: ${relative}`;
     if (!isProbablyTextFile(target))
-        return `Not a text corpus file: ${relative}`;
+        return `Not a text source file: ${relative}`;
     if (stat.size > MAX_FILE_BYTES) {
-        return `Corpus file is too large to read through source-search: ${relative}`;
+        return `Source file is too large to read through source-search: ${relative}`;
     }
     const raw = fs.readFileSync(target, "utf-8");
     if (raw.length <= MAX_READ_CHARS)
         return raw;
     return `${raw.slice(0, MAX_READ_CHARS)}\n\n... truncated at ${MAX_READ_CHARS} characters. Use a narrower path or direct rg for more context.`;
 }
-function listCorpus() {
-    const corpusRoot = getCorpusRoot();
-    const sections = ["templates"];
-    return sections.map((section) => {
-        const sectionRoot = path.join(corpusRoot, section);
-        const files = listFiles(sectionRoot);
-        const children = fs.existsSync(sectionRoot)
+function listSourceRoots() {
+    return getSourceRoots().map((root) => {
+        const files = listFiles(root.directory, root.directory, root.visibilityRoot);
+        const children = fs.existsSync(root.directory)
             ? fs
-                .readdirSync(sectionRoot, { withFileTypes: true })
+                .readdirSync(root.directory, { withFileTypes: true })
                 .filter((entry) => entry.isDirectory())
                 .map((entry) => entry.name)
                 .sort()
             : [];
         return {
-            section,
-            path: section,
+            section: root.prefix,
+            path: root.prefix,
             files: files.length,
             directories: children,
         };
@@ -273,27 +341,26 @@ function listCorpus() {
 }
 export default async function sourceSearchScript(args) {
     const parsed = parseArgs(args);
-    const corpusRoot = getCorpusRoot();
     if (parsed.help === "true") {
         console.log(`Usage: pnpm action source-search [options]
 
 Options:
-  --query <text>    Search source corpus by keyword
-  --path <path>     Read a corpus file or list a corpus directory
-  --list            List corpus sections
+  --query <text>    Search readable framework source by keyword
+  --path <path>     Read a source file or list a source directory
+  --list            List source roots
   --help            Show this help message`);
         return;
     }
-    if (!fs.existsSync(corpusRoot)) {
-        console.log(`Source corpus not found at ${corpusRoot}. Build or reinstall @agent-native/core so node_modules/@agent-native/core/corpus exists.`);
+    if (!hasSourceCorpus()) {
+        console.log("Version-matched source is not available. Build or reinstall @agent-native/core so its source corpus and readable package sources are present.");
         return;
     }
     if (parsed.list === "true") {
-        console.log(JSON.stringify(listCorpus(), null, 2));
+        console.log(JSON.stringify(listSourceRoots(), null, 2));
         return;
     }
     if (parsed.path) {
-        console.log(readCorpusPath(parsed.path));
+        console.log(readSourcePath(parsed.path));
         return;
     }
     if (parsed.query) {
@@ -310,7 +377,7 @@ Options:
             }
             console.log("");
         }
-        console.log("Use --path <file> to read a specific corpus file.");
+        console.log("Use --path <file> to read a specific source file.");
         return;
     }
     console.log("Provide --query, --path, or --list. Use --help for details.");

package/dist/search-utils/index.d.ts

@@ -1,7 +1,18 @@
 export type SearchMatchMode = "allTerms" | "anyTerm" | "phrase" | "regex";
+export type TextSearchMode = "substring" | "glob" | "sql-like" | "regex";
+export interface TextMatcher {
+    matches(value: string): boolean;
+    error?: string;
+}
 export declare function escapeLikeTerm(value: string): string;
 export declare function normalizeSearchTerms(query: string): string[];
 export declare function matchesSearchMode(value: string, query: string, mode: SearchMatchMode): boolean;
+/**
+ * Build a bounded, case-insensitive matcher for agent-facing text search.
+ * Regexes are deliberately constrained because these matchers may scan a
+ * packaged source corpus during a single agent turn.
+ */
+export declare function createTextMatcher(pattern: string, mode?: TextSearchMode): TextMatcher;
 export declare function buildSearchSnippet(value: string, terms: string[], maxLength?: number): string;
 export declare function scoreSearchText(fields: {
     title?: string | null;

package/dist/search-utils/index.js

@@ -1,4 +1,5 @@
 import safeRegex from "safe-regex2";
+const MAX_TEXT_SEARCH_PATTERN_LENGTH = 240;
 const STOPWORDS = new Set([
     "about",
     "and",
@@ -57,6 +58,77 @@ export function matchesSearchMode(value, query, mode) {
         ? tokens.every((term) => normalizedValue.includes(term))
         : tokens.some((term) => normalizedValue.includes(term));
 }
+/**
+ * Build a bounded, case-insensitive matcher for agent-facing text search.
+ * Regexes are deliberately constrained because these matchers may scan a
+ * packaged source corpus during a single agent turn.
+ */
+export function createTextMatcher(pattern, mode = "substring") {
+    if (!pattern) {
+        return { matches: () => false, error: "Search pattern cannot be empty." };
+    }
+    if (pattern.length > MAX_TEXT_SEARCH_PATTERN_LENGTH) {
+        return {
+            matches: () => false,
+            error: `Search pattern is limited to ${MAX_TEXT_SEARCH_PATTERN_LENGTH} characters.`,
+        };
+    }
+    if (mode === "substring") {
+        const normalized = pattern.toLowerCase();
+        return {
+            matches: (value) => value.toLowerCase().includes(normalized),
+        };
+    }
+    const regexSource = mode === "regex" ? pattern : wildcardPatternToRegex(pattern, mode);
+    try {
+        const matcher = new RegExp(regexSource, "isu");
+        if (mode === "regex" && !safeRegex(pattern)) {
+            return {
+                matches: () => false,
+                error: "Regex pattern is too complex for a bounded source search.",
+            };
+        }
+        return { matches: (value) => matcher.test(value) };
+    }
+    catch {
+        return {
+            matches: () => false,
+            error: `Invalid ${mode} search pattern.`,
+        };
+    }
+}
+function wildcardPatternToRegex(pattern, mode) {
+    let source = "";
+    let escaped = false;
+    for (const character of pattern) {
+        if (escaped) {
+            source += escapeRegexCharacter(character);
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        const isMany = mode === "glob" ? character === "*" : character === "%";
+        const isOne = mode === "glob" ? character === "?" : character === "_";
+        if (isMany) {
+            source += "[\\s\\S]*";
+        }
+        else if (isOne) {
+            source += "[\\s\\S]";
+        }
+        else {
+            source += escapeRegexCharacter(character);
+        }
+    }
+    if (escaped)
+        source += "\\\\";
+    return source;
+}
+function escapeRegexCharacter(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
 export function buildSearchSnippet(value, terms, maxLength = 260) {
     const text = normalizeText(value);
     if (text.length <= maxLength)