@microsoft/rayfin-docs 1.27.0

package/dist/loader.js

@@ -0,0 +1,296 @@
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
+import { basename, extname, join, relative, sep } from 'path';
+import { docKindToModule } from './discovery.js';
+const DEFAULT_MODULES = ['guide', 'host', 'ts-sdk'];
+function parseFrontMatter(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0]?.trim() !== '---') {
+        return { attributes: {}, body: markdown };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i]?.trim() === '---') {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return { attributes: {}, body: markdown };
+    }
+    const frontMatterLines = lines.slice(1, endIndex);
+    const attributes = {};
+    let currentArrayKey = null;
+    for (const line of frontMatterLines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed.startsWith('- ') && currentArrayKey) {
+            const value = trimmed.slice(2).trim();
+            const existing = attributes[currentArrayKey];
+            if (Array.isArray(existing)) {
+                existing.push(value);
+            }
+            else {
+                attributes[currentArrayKey] = [value];
+            }
+            continue;
+        }
+        const separatorIndex = trimmed.indexOf(':');
+        if (separatorIndex === -1) {
+            currentArrayKey = null;
+            continue;
+        }
+        const key = trimmed.slice(0, separatorIndex).trim();
+        let value = trimmed.slice(separatorIndex + 1).trim();
+        if (!value) {
+            attributes[key] = [];
+            currentArrayKey = key;
+            continue;
+        }
+        if (value.startsWith('[') && value.endsWith(']')) {
+            const inner = value.slice(1, -1).trim();
+            const parts = inner ? inner.split(',').map((part) => part.trim()) : [];
+            attributes[key] = parts.filter(Boolean);
+            currentArrayKey = null;
+            continue;
+        }
+        if (value.startsWith('"') && value.endsWith('"')) {
+            value = value.slice(1, -1);
+        }
+        attributes[key] = value;
+        currentArrayKey = null;
+    }
+    const body = lines.slice(endIndex + 1).join('\n');
+    return { attributes, body };
+}
+function extractTitle(markdown) {
+    const match = markdown.match(/^#\s+(.+)$/m);
+    return match?.[1]?.trim();
+}
+function extractSymbolsFromHeading(heading) {
+    const symbols = new Set();
+    const cleaned = heading.replace(/`/g, '').trim();
+    const typedMatch = cleaned.match(/^(Class|Interface|Type|Function|Method|Enum|Variable|Decorator|Namespace)\s*:\s*(.+)$/i);
+    if (typedMatch?.[2]) {
+        symbols.add(typedMatch[2].trim());
+    }
+    const backtickMatches = heading.match(/`([^`]+)`/g) ?? [];
+    for (const match of backtickMatches) {
+        const value = match.replace(/`/g, '').trim();
+        if (value) {
+            symbols.add(value);
+        }
+    }
+    const simpleMatch = cleaned.match(/^(?:\w+\s*:\s*)?([A-Za-z0-9_.$<>-]+)$/);
+    if (simpleMatch?.[1]) {
+        symbols.add(simpleMatch[1]);
+    }
+    return [...symbols].filter(Boolean);
+}
+function extractSymbolsFromFilename(filePath) {
+    const name = basename(filePath, extname(filePath));
+    if (!name ||
+        name.toLowerCase() === 'index' ||
+        name.toLowerCase() === 'readme') {
+        return [];
+    }
+    return [name];
+}
+function parseSections(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const sections = [];
+    let currentHeading = 'Overview';
+    let currentLevel = 1;
+    let buffer = [];
+    const flush = () => {
+        const content = buffer.join('\n').trim();
+        if (!content && currentHeading === 'Overview') {
+            buffer = [];
+            return;
+        }
+        sections.push({
+            heading: currentHeading,
+            level: currentLevel,
+            content,
+            symbols: extractSymbolsFromHeading(currentHeading),
+        });
+        buffer = [];
+    };
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{2,3})\s+(.+)$/);
+        if (headingMatch) {
+            flush();
+            currentHeading = headingMatch[2].trim();
+            currentLevel = headingMatch[1].length;
+            continue;
+        }
+        buffer.push(line);
+    }
+    flush();
+    return sections.filter((section) => section.content || section.heading !== 'Overview');
+}
+function collectMarkdownFiles(dir, visited = new Set(), realRoot) {
+    const realDir = realpathSync.native(dir);
+    if (realRoot && !realPathIsSelfOrDescendant(realDir, realRoot)) {
+        return [];
+    }
+    if (visited.has(realDir)) {
+        return [];
+    }
+    visited.add(realDir);
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip `preview` directories entirely. Preview docs are intentionally
+            // excluded from both the published Docusaurus build and the MCP/docs
+            // index so that feature-flagged or in-progress content is not surfaced.
+            if (entry.name === 'preview') {
+                continue;
+            }
+            let realEntryDir;
+            try {
+                realEntryDir = realpathSync.native(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (realRoot && !realPathIsSelfOrDescendant(realEntryDir, realRoot)) {
+                continue;
+            }
+            files.push(...collectMarkdownFiles(fullPath, visited, realRoot));
+            continue;
+        }
+        if (entry.isFile() && extname(entry.name).toLowerCase() === '.md') {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function realPathIsSelfOrDescendant(path, root) {
+    const normalizedPath = process.platform === 'win32' ? path.toLowerCase() : path;
+    const normalizedRoot = process.platform === 'win32' ? root.toLowerCase() : root;
+    return (normalizedPath === normalizedRoot ||
+        normalizedPath.startsWith(normalizedRoot + sep));
+}
+/**
+ * Build a single `DocEntry` from a markdown file. Shared by both the
+ * legacy {@link loadDocs} (bundled `assetsRoot/docs/<module>/...` layout)
+ * and the per-package {@link loadDocsFromPackage} (Phase 2+).
+ *
+ * `idPrefix` and `pathRoot` decouple the entry's identity (`<prefix>:<path>`)
+ * from the actual file location, so per-package layouts can produce stable
+ * IDs without leaking package roots into the entry.
+ */
+function buildEntry(filePath, module, pathRoot, source, idPrefix = module) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const frontMatter = parseFrontMatter(raw);
+    const content = frontMatter.body.trim();
+    const title = (typeof frontMatter.attributes.title === 'string'
+        ? frontMatter.attributes.title
+        : undefined) ??
+        extractTitle(content) ??
+        basename(filePath, extname(filePath));
+    const frontMatterSymbols = frontMatter.attributes.symbols;
+    const symbolsFromFrontMatter = Array.isArray(frontMatterSymbols)
+        ? frontMatterSymbols
+        : typeof frontMatterSymbols === 'string'
+            ? [frontMatterSymbols]
+            : [];
+    const sections = parseSections(content);
+    const symbols = new Set([
+        ...symbolsFromFrontMatter,
+        ...extractSymbolsFromFilename(filePath),
+    ]);
+    for (const section of sections) {
+        for (const symbol of section.symbols) {
+            symbols.add(symbol);
+        }
+    }
+    const relativePath = relative(pathRoot, filePath).replace(/\\/g, '/');
+    const entry = {
+        id: `${idPrefix}:${relativePath}`,
+        module,
+        path: relativePath,
+        title,
+        content,
+        symbols: [...symbols].filter(Boolean),
+        sections,
+    };
+    if (source) {
+        entry.source = source;
+    }
+    return entry;
+}
+export function loadDocs(assetsRoot, modules = DEFAULT_MODULES) {
+    const entries = [];
+    for (const moduleName of modules) {
+        const moduleRoot = join(assetsRoot, 'docs', moduleName);
+        if (!existsSync(moduleRoot)) {
+            continue;
+        }
+        const files = collectMarkdownFiles(moduleRoot);
+        for (const filePath of files) {
+            entries.push(buildEntry(filePath, moduleName, assetsRoot));
+        }
+    }
+    return entries;
+}
+/**
+ * Walk the docs tree of a discovered package and produce {@link DocEntry}
+ * items tagged with the package's source metadata.
+ *
+ * Per design.md, discovered packages have a flat `<packageRoot>/<dir>/`
+ * layout (no `/docs/<module>/` nesting). The manifest's `kind` is
+ * mapped to a legacy `DocModule` so existing CLI/MCP filters
+ * (`--module ts-sdk`) keep working through the migration.
+ *
+ * **Symlink safety.** The manifest validator in `discovery.ts` rejects
+ * `..` segments in the manifest's `dir` string, but a malicious package
+ * could still place a symlink at `<packageRoot>/<dir>` or inside that
+ * tree pointing to e.g. `/etc/passwd`. We resolve the package root,
+ * docs root, walked directories, and every walked file's realpath, then
+ * skip anything that escapes the trusted package/docs boundaries.
+ */
+export function loadDocsFromPackage(pkg) {
+    const docsRoot = join(pkg.packageRoot, pkg.manifest.dir);
+    if (!existsSync(docsRoot)) {
+        return [];
+    }
+    const realPackageRoot = realpathSync.native(pkg.packageRoot);
+    const realDocsRoot = realpathSync.native(docsRoot);
+    if (!realPathIsSelfOrDescendant(realDocsRoot, realPackageRoot)) {
+        return [];
+    }
+    const module = docKindToModule(pkg.manifest.kind);
+    const source = {
+        module: pkg.manifest.module,
+        kind: pkg.manifest.kind,
+        packageName: pkg.packageName,
+        packageVersion: pkg.packageVersion,
+    };
+    const files = collectMarkdownFiles(docsRoot, new Set(), realDocsRoot);
+    const safe = [];
+    for (const filePath of files) {
+        let real;
+        try {
+            real = realpathSync.native(filePath);
+        }
+        catch {
+            // Broken symlink or missing file by the time we resolve. Skip
+            // rather than treating as fatal — discovery is defensive.
+            continue;
+        }
+        // realDocsRoot ends without a trailing separator; require the
+        // resolved real path to be `realDocsRoot` itself or a descendant
+        // (`realDocsRoot/...`). Reject anything else as a symlink escape.
+        if (!realPathIsSelfOrDescendant(real, realDocsRoot)) {
+            continue;
+        }
+        safe.push(filePath);
+    }
+    return safe.map((filePath) => buildEntry(filePath, module, docsRoot, source, pkg.manifest.module));
+}
+//# sourceMappingURL=loader.js.map

package/dist/search.d.ts

@@ -0,0 +1,72 @@
+import MiniSearch, { type Options as MiniSearchOptions } from 'minisearch';
+import type { DocEntry, DocModule, DocSearchResult, DocSearchScope, DocSectionRef } from './types';
+/**
+ * Schema version for the on-disk prebuilt search index
+ * (`assets/docs.search.json`). Bumped on any breaking change to the
+ * serialized structure so a stale prebuilt forces a runtime fallback.
+ *
+ * Version 2: stores the MiniSearch index as a plain object (consumed by
+ * `MiniSearch.loadJS`) instead of a pre-stringified `miniJSON` field.
+ * Avoids escape-bloating the asset and a redundant second `JSON.parse`
+ * on the cold-start path that every CLI invocation pays.
+ */
+export declare const DOCS_INDEX_SCHEMA_VERSION = 2;
+/**
+ * Single source of truth for MiniSearch construction. Both `createDocsIndex`
+ * (build-time and runtime source-build path) and `MiniSearch.loadJS`
+ * (runtime prebuilt path) read from this object so a config change in source
+ * is automatically reflected by `DOCS_SEARCH_CONFIG_FINGERPRINT` below; a
+ * fingerprint mismatch triggers a runtime fallback.
+ *
+ * Frozen at module load so a runtime mutation can't desync from the
+ * fingerprint stored in the prebuilt envelope.
+ */
+export declare const DOCS_SEARCH_OPTIONS: MiniSearchOptions<DocEntry>;
+/**
+ * Stable fingerprint of `DOCS_SEARCH_OPTIONS`. Used in the prebuilt index
+ * envelope so a runtime that reads a prebuilt JSON with a different config
+ * falls back to source-building rather than silently using stale options.
+ */
+export declare const DOCS_SEARCH_CONFIG_FINGERPRINT: string;
+export interface DocsIndex {
+    mini: MiniSearch<DocEntry>;
+    entriesById: Map<string, DocEntry>;
+    symbolToSections: Map<string, DocSectionRef[]>;
+}
+export declare function createDocsIndex(entries: DocEntry[]): DocsIndex;
+/**
+ * Envelope written to `assets/docs.search.json` by the build-time index
+ * emitter and read by `loadDocsIndexFromPrebuilt` at runtime. Versioned and
+ * fingerprinted so a runtime that finds a stale or mismatched prebuilt
+ * silently falls back to source-building rather than serving incorrect data.
+ *
+ * `miniSerialized` holds the plain-object form returned by
+ * `MiniSearch#toJSON()`. Storing the live object (not a pre-stringified
+ * inner string) means the outer `JSON.stringify` of the envelope handles
+ * serialization exactly once, and the runtime load is a single
+ * `JSON.parse` followed by `MiniSearch.loadJS` — no double-parse and no
+ * escape-bloated string.
+ *
+ * `symbolToSections` is intentionally NOT persisted. We tried in PR #1143
+ * round 3 and the empirical eval showed the larger JSON parse cost ate
+ * the rebuild savings - net mean +3.4 ms across the default suite. The
+ * runtime walk over `entries` is the right tradeoff.
+ */
+export interface PrebuiltDocsIndex {
+    schemaVersion: number;
+    configFingerprint: string;
+    modules: DocModule[];
+    entries: DocEntry[];
+    miniSerialized: ReturnType<MiniSearch<DocEntry>['toJSON']>;
+}
+/** Build the on-disk envelope from a freshly constructed in-memory index. */
+export declare function serializeDocsIndex(entries: DocEntry[], modules: DocModule[], index: DocsIndex): PrebuiltDocsIndex;
+/**
+ * Rehydrate a `DocsIndex` from a prebuilt envelope. The caller is expected
+ * to have already validated that the envelope's `schemaVersion`,
+ * `configFingerprint`, and `modules` match what the runtime needs - this
+ * helper trusts those invariants.
+ */
+export declare function loadDocsIndexFromPrebuilt(prebuilt: PrebuiltDocsIndex): DocsIndex;
+export declare function searchDocs(index: DocsIndex, query: string, moduleFilter?: DocModule, limit?: number, scope?: DocSearchScope): DocSearchResult[];
+//# sourceMappingURL=search.d.ts.map

package/dist/search.js

@@ -0,0 +1,254 @@
+import MiniSearch from 'minisearch';
+/**
+ * Schema version for the on-disk prebuilt search index
+ * (`assets/docs.search.json`). Bumped on any breaking change to the
+ * serialized structure so a stale prebuilt forces a runtime fallback.
+ *
+ * Version 2: stores the MiniSearch index as a plain object (consumed by
+ * `MiniSearch.loadJS`) instead of a pre-stringified `miniJSON` field.
+ * Avoids escape-bloating the asset and a redundant second `JSON.parse`
+ * on the cold-start path that every CLI invocation pays.
+ */
+export const DOCS_INDEX_SCHEMA_VERSION = 2;
+/**
+ * Single source of truth for MiniSearch construction. Both `createDocsIndex`
+ * (build-time and runtime source-build path) and `MiniSearch.loadJS`
+ * (runtime prebuilt path) read from this object so a config change in source
+ * is automatically reflected by `DOCS_SEARCH_CONFIG_FINGERPRINT` below; a
+ * fingerprint mismatch triggers a runtime fallback.
+ *
+ * Frozen at module load so a runtime mutation can't desync from the
+ * fingerprint stored in the prebuilt envelope.
+ */
+export const DOCS_SEARCH_OPTIONS = Object.freeze({
+    fields: ['title', 'content', 'symbols'],
+    // Keep storeFields minimal - everything the search/snippet path needs
+    // is fetched via `entriesById`, not the index. `module` is stored only
+    // because some callers filter on it directly from MiniSearch results.
+    storeFields: ['module'],
+    searchOptions: Object.freeze({
+        boost: Object.freeze({ title: 2, symbols: 1.5 }),
+        prefix: true,
+    }),
+});
+/**
+ * Recursively-stable JSON.stringify that sorts keys at every nesting level.
+ * Plain `JSON.stringify(obj, Object.keys(obj).sort())` only applies the
+ * key whitelist at the top level — nested object keys silently disappear,
+ * which made `DOCS_SEARCH_CONFIG_FINGERPRINT` blind to changes inside
+ * `searchOptions.boost`, `searchOptions.prefix`, etc. Captured by the
+ * deep-review pass on PR #1143.
+ */
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const parts = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+    return `{${parts.join(',')}}`;
+}
+/**
+ * Stable fingerprint of `DOCS_SEARCH_OPTIONS`. Used in the prebuilt index
+ * envelope so a runtime that reads a prebuilt JSON with a different config
+ * falls back to source-building rather than silently using stale options.
+ */
+export const DOCS_SEARCH_CONFIG_FINGERPRINT = stableStringify(DOCS_SEARCH_OPTIONS);
+export function createDocsIndex(entries) {
+    const mini = new MiniSearch(DOCS_SEARCH_OPTIONS);
+    mini.addAll(entries);
+    const { entriesById, symbolToSections } = buildEntryAndSymbolMaps(entries);
+    return { mini, entriesById, symbolToSections };
+}
+/**
+ * Build the `entriesById` and `symbolToSections` maps from raw entries.
+ * Extracted so the prebuilt-index load path can rebuild these maps without
+ * paying for minisearch index construction.
+ */
+function buildEntryAndSymbolMaps(entries) {
+    const entriesById = new Map();
+    const symbolToSections = new Map();
+    for (const entry of entries) {
+        entriesById.set(entry.id, entry);
+        const sectionSymbols = new Set();
+        for (const section of entry.sections) {
+            if (!section.symbols.length) {
+                continue;
+            }
+            for (const symbol of section.symbols) {
+                sectionSymbols.add(symbol);
+                const key = symbol.toLowerCase();
+                const list = symbolToSections.get(key) ?? [];
+                list.push({
+                    symbol,
+                    entryId: entry.id,
+                    module: entry.module,
+                    path: entry.path,
+                    title: entry.title,
+                    heading: section.heading,
+                    content: section.content,
+                    ...(entry.source ? { source: entry.source } : {}),
+                });
+                symbolToSections.set(key, list);
+            }
+        }
+        for (const symbol of entry.symbols) {
+            if (sectionSymbols.has(symbol)) {
+                continue;
+            }
+            const key = symbol.toLowerCase();
+            const list = symbolToSections.get(key) ?? [];
+            list.push({
+                symbol,
+                entryId: entry.id,
+                module: entry.module,
+                path: entry.path,
+                title: entry.title,
+                heading: entry.title,
+                content: entry.content,
+                ...(entry.source ? { source: entry.source } : {}),
+            });
+            symbolToSections.set(key, list);
+        }
+    }
+    return { entriesById, symbolToSections };
+}
+/** Build the on-disk envelope from a freshly constructed in-memory index. */
+export function serializeDocsIndex(entries, modules, index) {
+    return {
+        schemaVersion: DOCS_INDEX_SCHEMA_VERSION,
+        configFingerprint: DOCS_SEARCH_CONFIG_FINGERPRINT,
+        modules: [...modules].sort(),
+        entries,
+        miniSerialized: index.mini.toJSON(),
+    };
+}
+/**
+ * Rehydrate a `DocsIndex` from a prebuilt envelope. The caller is expected
+ * to have already validated that the envelope's `schemaVersion`,
+ * `configFingerprint`, and `modules` match what the runtime needs - this
+ * helper trusts those invariants.
+ */
+export function loadDocsIndexFromPrebuilt(prebuilt) {
+    const mini = MiniSearch.loadJS(prebuilt.miniSerialized, DOCS_SEARCH_OPTIONS);
+    const { entriesById, symbolToSections } = buildEntryAndSymbolMaps(prebuilt.entries);
+    return { mini, entriesById, symbolToSections };
+}
+function buildSnippet(content, query, maxLength = 200) {
+    const lower = content.toLowerCase();
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    let matchIndex = -1;
+    let matchLength = 0;
+    for (const term of terms) {
+        const index = lower.indexOf(term);
+        if (index !== -1 && (matchIndex === -1 || index < matchIndex)) {
+            matchIndex = index;
+            matchLength = term.length;
+        }
+    }
+    if (matchIndex === -1) {
+        const snippet = content.slice(0, maxLength);
+        return { snippet, snippetStart: 0, snippetEnd: snippet.length };
+    }
+    const start = Math.max(0, matchIndex - Math.floor(maxLength / 2));
+    const end = Math.min(content.length, start + maxLength);
+    const snippet = content.slice(start, end);
+    return {
+        snippet,
+        snippetStart: matchIndex,
+        snippetEnd: matchIndex + matchLength,
+    };
+}
+function searchDocsByContent(index, query, moduleFilter) {
+    const results = index.mini.search(query);
+    const filtered = moduleFilter
+        ? results.filter((result) => result.module === moduleFilter)
+        : results;
+    return filtered.map((result) => {
+        const entry = index.entriesById.get(result.id);
+        const content = entry?.content ?? '';
+        const { snippet, snippetStart, snippetEnd } = buildSnippet(content, query);
+        return {
+            id: result.id,
+            module: (entry?.module ?? result.module),
+            path: (entry?.path ?? result.path),
+            title: (entry?.title ?? result.title),
+            snippet,
+            snippetStart,
+            snippetEnd,
+            score: result.score ?? 0,
+            symbols: entry?.symbols ?? result.symbols ?? [],
+            kind: 'doc',
+            ...(entry?.source ? { source: entry.source } : {}),
+        };
+    });
+}
+function scoreSymbolMatch(symbolKey, terms) {
+    let score = 0;
+    for (const term of terms) {
+        if (symbolKey === term) {
+            score += 3;
+            continue;
+        }
+        if (symbolKey.startsWith(term)) {
+            score += 2;
+            continue;
+        }
+        if (symbolKey.includes(term)) {
+            score += 1;
+        }
+    }
+    return score;
+}
+function searchDocsBySymbols(index, query, moduleFilter) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (!terms.length) {
+        return [];
+    }
+    const results = [];
+    for (const [symbolKey, sections] of index.symbolToSections.entries()) {
+        const score = scoreSymbolMatch(symbolKey, terms);
+        if (score <= 0) {
+            continue;
+        }
+        for (const section of sections) {
+            if (moduleFilter && section.module !== moduleFilter) {
+                continue;
+            }
+            const { snippet, snippetStart, snippetEnd } = buildSnippet(section.content, query);
+            results.push({
+                id: section.entryId,
+                module: section.module,
+                path: section.path,
+                title: section.title,
+                heading: section.heading,
+                symbol: section.symbol,
+                snippet,
+                snippetStart,
+                snippetEnd,
+                score,
+                symbols: [section.symbol],
+                kind: 'symbol',
+                ...(section.source ? { source: section.source } : {}),
+            });
+        }
+    }
+    return results;
+}
+export function searchDocs(index, query, moduleFilter, limit = 10, scope = 'docs') {
+    if (scope === 'docs') {
+        return searchDocsByContent(index, query, moduleFilter).slice(0, limit);
+    }
+    if (scope === 'symbols') {
+        const symbolResults = searchDocsBySymbols(index, query, moduleFilter).sort((a, b) => b.score - a.score);
+        return symbolResults.slice(0, limit);
+    }
+    const docResults = searchDocsByContent(index, query, moduleFilter);
+    const symbolResults = searchDocsBySymbols(index, query, moduleFilter);
+    return [...docResults, ...symbolResults]
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}
+//# sourceMappingURL=search.js.map