@ltm-alpha/alpha-cs 1.6.0

package/dist/search/identifier-segments.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Identifier-segment utilities for the prompt hook's graph-derived gate
+ * (name_segment_vocab): symbol names split into the words a human would use
+ * for them in prose, and prompt prose normalized into candidate words to look
+ * those segments up with.
+ *
+ * "OrderStateMachine" → order / state / machine — so the French prompt
+ * "comment marche la state machine des commandes ?" (or any language's prose
+ * naming the concept in Latin script) can be verified against the graph
+ * without a keyword list ever knowing the words. The FTS index can't serve
+ * this — its tokenizer keeps camelCase names as single tokens — which is why
+ * segments are materialized at index time instead (see schema.sql,
+ * name_segment_vocab).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitIdentifierSegments = splitIdentifierSegments;
+exports.normalizeProseWord = normalizeProseWord;
+exports.extractProseCandidates = extractProseCandidates;
+exports.extractSegmentSearchWords = extractSegmentSearchWords;
+exports.segmentLookupVariants = segmentLookupVariants;
+/** Bounds keep degenerate identifiers (minified names, hashes) from bloating
+ *  the vocab: segments outside them carry no prose signal anyway. */
+const MIN_SEGMENT_CHARS = 2;
+const MAX_SEGMENT_CHARS = 32;
+const MAX_SEGMENTS_PER_NAME = 12;
+/**
+ * Split a symbol or file name into lowercase word segments.
+ *
+ * Handles camelCase / PascalCase (inner lower→Upper), acronym runs
+ * ("HTMLParser" → html/parser), snake_case / kebab-case / dotted file names
+ * (non-alphanumerics separate), and keeps digits glued to their word
+ * ("base64Encode" → base64/encode). Digit-only fragments are dropped.
+ */
+function splitIdentifierSegments(name) {
+    if (!name)
+        return [];
+    const out = new Set();
+    for (const run of name.match(/[\p{L}\p{N}]+/gu) ?? []) {
+        // Split before an Upper that follows lower/digit (camelCase hump), and
+        // before the last Upper of an acronym run when a lowercase follows
+        // ("HTMLParser" → HTML | Parser).
+        const parts = run.split(/(?<=[\p{Ll}\p{N}])(?=\p{Lu})|(?<=\p{Lu})(?=\p{Lu}\p{Ll})/u);
+        for (const part of parts) {
+            if (out.size >= MAX_SEGMENTS_PER_NAME)
+                return [...out];
+            const seg = part.toLowerCase();
+            if (seg.length < MIN_SEGMENT_CHARS || seg.length > MAX_SEGMENT_CHARS)
+                continue;
+            if (/^\p{N}+$/u.test(seg))
+                continue;
+            out.add(seg);
+        }
+    }
+    return [...out];
+}
+/**
+ * Normalize a prose word for segment lookup: lowercase + strip diacritics
+ * (NFD, drop combining marks), so "références" matches the segment
+ * "references" and "résolution" matches "resolution". Identifier segments are
+ * overwhelmingly ASCII, so this is what buys Latin-script languages their
+ * cross-lingual reach on loanwords.
+ */
+function normalizeProseWord(word) {
+    return word.normalize('NFD').replace(/\p{M}+/gu, '').toLowerCase();
+}
+/** Candidate cap: a prompt's first words carry its subject; scanning an essay
+ *  buys nothing and the vocab lookup cost scales with this. */
+const MAX_PROSE_CANDIDATES = 16;
+const MIN_PROSE_CHARS = 4; // "the"/"des"/"une"/"fix" out; "auth"/"flow"/"path" in
+const MAX_PROSE_CHARS = 24; // an unsegmented-script sentence is one giant run — skip it
+/**
+ * English prompt words that are never evidence a symbol was NAMED, however
+ * rare their segment happens to be in a given repo: function words, filler,
+ * hyper-common dev verbs, and words ABOUT code rather than OF it ("rename
+ * this file", "there's an issue"). Measured FPs that motivated this: "fix
+ * THIS typo" matched `resolveDeferredThisMemberRefs` (repo-rare segment!),
+ * "WRITE a haiku" matched `writeConfig`.
+ *
+ * English-only ON PURPOSE — this is not the #1126 keyword treadmill:
+ * identifiers are written in English, so only English prose words can
+ * accidentally collide with segments. Other languages' function words
+ * ("avec", "pendant", "dieser") don't match anything and need no list.
+ * Domain nouns ("state", "checkout", "order") stay OUT — they are exactly
+ * the signal; the rarity/co-occurrence rules judge them per-repo.
+ */
+const ENGLISH_PROSE_STOPWORDS = new Set([
+    'about', 'above', 'actually', 'after', 'again', 'against', 'almost', 'along', 'also', 'always',
+    'another', 'anything', 'around', 'away', 'back', 'because', 'been', 'before', 'behind', 'being',
+    'below', 'best', 'better', 'between', 'both', 'cannot', 'come', 'could', 'does', 'doing', 'done',
+    'down', 'each', 'either', 'else', 'even', 'ever', 'every', 'everything', 'fine', 'first', 'from',
+    'getting', 'give', 'goes', 'going', 'gone', 'good', 'great', 'have', 'having', 'help', 'here',
+    'inside', 'instead', 'into', 'just', 'keep', 'know', 'last', 'least', 'less', 'like', 'likely',
+    'little', 'look', 'looking', 'made', 'make', 'making', 'many', 'maybe', 'mind', 'more', 'most',
+    'much', 'must', 'need', 'needs', 'never', 'next', 'nice', 'none', 'nothing', 'okay', 'only',
+    'onto', 'other', 'otherwise', 'over', 'please', 'pretty', 'probably', 'quite', 'rather', 'really',
+    'right', 'same', 'seem', 'seems', 'should', 'show', 'since', 'some', 'someone', 'something',
+    'somewhere', 'soon', 'still', 'such', 'sure', 'take', 'than', 'thank', 'thanks', 'that', 'their',
+    'them', 'then', 'there', 'these', 'they', 'thing', 'things', 'think', 'this', 'those', 'though',
+    'tried', 'tries', 'trying', 'under', 'until', 'upon', 'very', 'want', 'wants', 'well', 'went',
+    'were', 'what', 'when', 'which', 'while', 'will', 'wish', 'with', 'within', 'without', 'would',
+    'wrong', 'your', 'yours',
+    // words ABOUT code, not OF it — present in a huge share of prompts while
+    // almost never naming the symbol the user means
+    'again', 'change', 'changes', 'check', 'class', 'classes', 'code', 'detail', 'details',
+    'directory', 'error', 'errors', 'example', 'examples', 'file', 'files', 'folder', 'function',
+    'functions', 'issue', 'issues', 'line', 'lines', 'method', 'methods', 'name', 'names', 'problem',
+    'problems', 'project', 'question', 'questions', 'rename', 'test', 'tests', 'type', 'types',
+    'update', 'value', 'values', 'warning', 'warnings', 'work', 'working', 'write', 'writing',
+]);
+/**
+ * Candidate words from a prompt for segment-vocabulary lookup, in order of
+ * appearance: Unicode letter/digit runs, normalized via
+ * {@link normalizeProseWord}, length-bounded, digit-only dropped,
+ * {@link ENGLISH_PROSE_STOPWORDS} dropped, deduped, capped. Everything that
+ * survives is judged per-repo by the rarity and co-occurrence rules in
+ * Alpha Code Sense.getSegmentMatches — there is no domain-word list.
+ */
+function extractProseCandidates(prompt) {
+    if (!prompt)
+        return [];
+    const seen = new Set();
+    for (const run of prompt.match(/[\p{L}\p{N}]+/gu) ?? []) {
+        if (seen.size >= MAX_PROSE_CANDIDATES)
+            break;
+        if (run.length > MAX_PROSE_CHARS)
+            continue;
+        const w = normalizeProseWord(run);
+        if (w.length < MIN_PROSE_CHARS || w.length > MAX_PROSE_CHARS)
+            continue;
+        if (/^\p{N}+$/u.test(w))
+            continue;
+        if (ENGLISH_PROSE_STOPWORDS.has(w))
+            continue;
+        seen.add(w);
+    }
+    return [...seen];
+}
+/**
+ * Words to look up in the segment vocabulary for a SEARCH query (as opposed
+ * to a prompt-hook gate): the query's prose candidates PLUS the segments of
+ * its identifier-shaped tokens. An agent's query names concepts both ways —
+ * "auto-scroll to bottom" (prose) and "atBottom tracking" (camel) — and the
+ * camel token must still reach the segment "bottom" even though the whole
+ * token matches no name. Same stopword/length rules as the hook path, since
+ * both feeds run through {@link extractProseCandidates}.
+ */
+function extractSegmentSearchWords(query) {
+    if (!query)
+        return [];
+    const words = new Set(extractProseCandidates(query));
+    const segments = [];
+    for (const run of query.match(/[\p{L}\p{N}]+/gu) ?? []) {
+        // Only camel-humped tokens contribute segments — a plain word's
+        // "segments" are itself (already covered above), and snake_case arrives
+        // as separate runs because `_` is not a letter.
+        if (/[\p{Ll}\p{N}]\p{Lu}/u.test(run)) {
+            segments.push(...splitIdentifierSegments(run));
+        }
+    }
+    if (segments.length > 0) {
+        for (const w of extractProseCandidates(segments.join(' ')))
+            words.add(w);
+    }
+    return [...words];
+}
+/**
+ * Lookup variants for a prose word: the word itself plus light plural folding
+ * ("services" → service, "dependencies" → dependencie/dependency is NOT
+ * attempted — only a trailing s/es strip), so common plurals still hit their
+ * singular segment. Returned variants map back to the same original word.
+ *
+ * The strips are keyed on English plural spelling (#1145), in three classes:
+ * - UNAMBIGUOUS `-es` (after x/sh/ss/zz: boxes, hashes, classes, quizzes) —
+ *   strip 2 only. Stripping 1 minted a bogus sibling ("classes" → classe).
+ * - AMBIGUOUS endings (`-ches`/`-ses`/`-zes`/`-oes`): spelling alone can't
+ *   split patches(+es) from caches(+s), lenses from databases, heroes from
+ *   shoes — emit BOTH candidate keys and let the vocab lookup decide; a miss
+ *   is an ignored key, a wrong exclusive guess would LOSE the real match.
+ * - Everything else ending in `-s` — a bare `-s` plural (services, machines,
+ *   cookies): strip 1 only. Stripping 2 minted "services" → servic.
+ * A trailing `-ss` is a singular (class, process), not a plural: no strip —
+ * that used to mint "class" → clas.
+ */
+function segmentLookupVariants(word) {
+    const variants = [word];
+    const canStrip2 = word.length >= MIN_PROSE_CHARS + 2;
+    const canStrip1 = word.length >= MIN_PROSE_CHARS + 1;
+    if (/(?:x|sh|ss|zz)es$/.test(word)) {
+        if (canStrip2)
+            variants.push(word.slice(0, -2));
+    }
+    else if (/(?:ch|s|z|o)es$/.test(word)) {
+        if (canStrip2)
+            variants.push(word.slice(0, -2));
+        if (canStrip1)
+            variants.push(word.slice(0, -1));
+    }
+    else if (word.endsWith('s') && !word.endsWith('ss')) {
+        if (canStrip1)
+            variants.push(word.slice(0, -1));
+    }
+    return variants;
+}
+//# sourceMappingURL=identifier-segments.js.map

package/dist/search/identifier-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier-segments.js","sourceRoot":"","sources":["../../src/search/identifier-segments.ts"],"names":[],"mappings":"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"}

package/dist/search/query-parser.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Field-qualified search query parser.
+ *
+ * Splits a raw query like
+ *
+ *     kind:function name:auth path:src/api authenticate
+ *
+ * into structured filters (kind=function, name="auth", path prefix
+ * "src/api") plus the free-text portion ("authenticate") that goes
+ * to FTS. Free-text and filters compose: filters narrow the result
+ * set, FTS scores within the narrowed set.
+ *
+ * Recognised fields (case-insensitive, value is the rest until
+ * whitespace):
+ *
+ *   kind:    one of function|method|class|interface|struct|...
+ *   lang:    one of typescript|python|go|...   (alias: language:)
+ *   path:    case-insensitive substring of file_path
+ *   name:    case-insensitive substring of the symbol's name
+ *
+ * Unknown field prefixes (e.g. `foo:bar`) are passed through to FTS
+ * as plain text — that's how someone searching for `TODO:` gets a
+ * result instead of a parse error.
+ *
+ * Quoting:
+ *   kind:function path:"src/some path/with spaces" → handled by stripping
+ *   the surrounding double quotes from the value (single token only,
+ *   no nested escapes).
+ */
+import type { NodeKind, Language } from '../types';
+export interface ParsedQuery {
+    /** Free-text portion to feed to FTS / LIKE. May be empty. */
+    text: string;
+    /** kind: filters (OR'd). Empty when none specified. */
+    kinds: NodeKind[];
+    /** lang:/language: filters (OR'd). Empty when none specified. */
+    languages: Language[];
+    /** path: filters (OR'd, case-insensitive substring of file_path). Empty when none. */
+    pathFilters: string[];
+    /** name: filters (OR'd, case-insensitive substring of node.name). */
+    nameFilters: string[];
+}
+/**
+ * Parse a raw query into structured filters + remaining text.
+ * Always returns a value; never throws.
+ */
+export declare function parseQuery(raw: string): ParsedQuery;
+/**
+ * Damerau-Levenshtein-ish bounded edit distance. Returns `maxDist + 1`
+ * as soon as the distance is known to exceed `maxDist`; that early-exit
+ * makes the fuzzy fallback cheap even over tens of thousands of names.
+ *
+ * Pure DP, O(min(len(a), len(b))) memory. Compares case-folded inputs;
+ * callers should pass `lowercase(name)` strings.
+ */
+export declare function boundedEditDistance(a: string, b: string, maxDist: number): number;
+//# sourceMappingURL=query-parser.d.ts.map

package/dist/search/query-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-parser.d.ts","sourceRoot":"","sources":["../../src/search/query-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,iEAAiE;IACjE,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,sFAAsF;IACtF,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,qEAAqE;IACrE,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAiBD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAiFnD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2BjF"}

package/dist/search/query-parser.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Field-qualified search query parser.
+ *
+ * Splits a raw query like
+ *
+ *     kind:function name:auth path:src/api authenticate
+ *
+ * into structured filters (kind=function, name="auth", path prefix
+ * "src/api") plus the free-text portion ("authenticate") that goes
+ * to FTS. Free-text and filters compose: filters narrow the result
+ * set, FTS scores within the narrowed set.
+ *
+ * Recognised fields (case-insensitive, value is the rest until
+ * whitespace):
+ *
+ *   kind:    one of function|method|class|interface|struct|...
+ *   lang:    one of typescript|python|go|...   (alias: language:)
+ *   path:    case-insensitive substring of file_path
+ *   name:    case-insensitive substring of the symbol's name
+ *
+ * Unknown field prefixes (e.g. `foo:bar`) are passed through to FTS
+ * as plain text — that's how someone searching for `TODO:` gets a
+ * result instead of a parse error.
+ *
+ * Quoting:
+ *   kind:function path:"src/some path/with spaces" → handled by stripping
+ *   the surrounding double quotes from the value (single token only,
+ *   no nested escapes).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = parseQuery;
+exports.boundedEditDistance = boundedEditDistance;
+const types_1 = require("../types");
+// Derived from the canonical `NODE_KINDS` / `LANGUAGES` arrays in
+// types.ts so adding a new kind or language doesn't silently fall
+// through to plain text here.
+const KIND_VALUES = new Set(types_1.NODE_KINDS);
+const LANGUAGE_VALUES = new Set(types_1.LANGUAGES);
+/**
+ * Strip a surrounding pair of double quotes from `s`. Allows users to
+ * keep whitespace in path filters: `path:"my dir/file"`.
+ */
+function unquote(s) {
+    if (s.length >= 2 && s.startsWith('"') && s.endsWith('"'))
+        return s.slice(1, -1);
+    return s;
+}
+/**
+ * Parse a raw query into structured filters + remaining text.
+ * Always returns a value; never throws.
+ */
+function parseQuery(raw) {
+    const out = {
+        text: '',
+        kinds: [],
+        languages: [],
+        pathFilters: [],
+        nameFilters: [],
+    };
+    // Tokenise on whitespace, preserving quoted spans as part of the
+    // current token. Quotes can appear at the start (`"…"`) OR mid-token
+    // (`path:"…"`); in both cases everything from the opening `"` to the
+    // matching `"` is included in the token, whitespace and all.
+    const tokens = [];
+    let i = 0;
+    while (i < raw.length) {
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+        if (i >= raw.length)
+            break;
+        const start = i;
+        while (i < raw.length && !/\s/.test(raw[i])) {
+            if (raw[i] === '"') {
+                const end = raw.indexOf('"', i + 1);
+                if (end === -1) {
+                    // Unterminated quote — swallow the rest of the input as
+                    // one token. Forgiving rather than throwing.
+                    i = raw.length;
+                    break;
+                }
+                i = end + 1;
+                continue;
+            }
+            i++;
+        }
+        tokens.push(raw.slice(start, i));
+    }
+    const textParts = [];
+    for (const tok of tokens) {
+        const colon = tok.indexOf(':');
+        if (colon <= 0 || colon === tok.length - 1) {
+            textParts.push(tok);
+            continue;
+        }
+        const key = tok.slice(0, colon).toLowerCase();
+        const valueRaw = unquote(tok.slice(colon + 1));
+        if (!valueRaw) {
+            textParts.push(tok);
+            continue;
+        }
+        switch (key) {
+            case 'kind': {
+                if (KIND_VALUES.has(valueRaw)) {
+                    out.kinds.push(valueRaw);
+                }
+                else {
+                    textParts.push(tok);
+                }
+                break;
+            }
+            case 'lang':
+            case 'language': {
+                const lower = valueRaw.toLowerCase();
+                if (LANGUAGE_VALUES.has(lower)) {
+                    out.languages.push(lower);
+                }
+                else {
+                    textParts.push(tok);
+                }
+                break;
+            }
+            case 'path':
+                out.pathFilters.push(valueRaw);
+                break;
+            case 'name':
+                out.nameFilters.push(valueRaw);
+                break;
+            default:
+                textParts.push(tok);
+        }
+    }
+    out.text = textParts.join(' ').trim();
+    return out;
+}
+/**
+ * Damerau-Levenshtein-ish bounded edit distance. Returns `maxDist + 1`
+ * as soon as the distance is known to exceed `maxDist`; that early-exit
+ * makes the fuzzy fallback cheap even over tens of thousands of names.
+ *
+ * Pure DP, O(min(len(a), len(b))) memory. Compares case-folded inputs;
+ * callers should pass `lowercase(name)` strings.
+ */
+function boundedEditDistance(a, b, maxDist) {
+    if (a === b)
+        return 0;
+    const al = a.length;
+    const bl = b.length;
+    if (Math.abs(al - bl) > maxDist)
+        return maxDist + 1;
+    if (al === 0)
+        return bl;
+    if (bl === 0)
+        return al;
+    let prev = new Array(bl + 1);
+    let cur = new Array(bl + 1);
+    for (let j = 0; j <= bl; j++)
+        prev[j] = j;
+    for (let i = 1; i <= al; i++) {
+        cur[0] = i;
+        let rowMin = cur[0];
+        for (let j = 1; j <= bl; j++) {
+            const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+            const insertion = cur[j - 1] + 1;
+            const deletion = prev[j] + 1;
+            const substitution = prev[j - 1] + cost;
+            cur[j] = Math.min(insertion, deletion, substitution);
+            if (cur[j] < rowMin)
+                rowMin = cur[j];
+        }
+        if (rowMin > maxDist)
+            return maxDist + 1;
+        [prev, cur] = [cur, prev];
+    }
+    return prev[bl];
+}
+//# sourceMappingURL=query-parser.js.map

package/dist/search/query-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-parser.js","sourceRoot":"","sources":["../../src/search/query-parser.ts"],"names":[],"mappings":"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"}

package/dist/search/query-paths.d.ts

@@ -0,0 +1,57 @@
+/**
+ * File-path recognition for explore queries.
+ *
+ * Agents routinely name files by path in a `codegraph_explore` query —
+ * "the scroll logic in src/routes/m/projects/[id]/runs/[runId]/+page.svelte" —
+ * and until this module existed those spans were SHREDDED by the downstream
+ * tokenizers instead of being read as file references:
+ *
+ *   - the named-symbol seeder splits on `[\s,()[\]]+`, so SvelteKit/Next
+ *     bracketed segments (`[id]`, `[runId]`) and route groups (`(protected)`)
+ *     exploded the path into fragments; the identifier-shaped survivors
+ *     (`runId`, `scope`) then seeded as "symbols the agent named" and
+ *     headlined the blast radius;
+ *   - FTS saw the fragments (`page`, `chat`, `runs`) and admitted every
+ *     sibling `+page.svelte` in the repo, which ate the output envelope and
+ *     truncated the files the agent actually asked for.
+ *
+ * `extractQueryPaths` finds path-like spans — slashed paths, dotted basenames,
+ * and extension-less kebab basenames (`background-image-table`, the spelling
+ * import paths and prose actually use) — resolves them against the INDEXED
+ * file list (resolution IS the detector — `and/or`, `gen_server:call/2`,
+ * `non-blocking` and other path-shaped non-paths match nothing and are left
+ * alone), and returns the matches as pinned files plus the query with those
+ * spans removed.
+ * Callers treat pinned files as first-class: guaranteed admission, top rank,
+ * funded first. Pure string work — no DB, no fs — so it is trivially testable
+ * and safe inside the query-pool workers.
+ */
+export interface QueryPathExtraction {
+    /** The query with resolved/clearly-path spans removed, whitespace-joined. */
+    strippedQuery: string;
+    /** Indexed file paths the query named, appearance-ordered, deduped. */
+    pinnedFiles: string[];
+    /**
+     * Spans that are unambiguously path-shaped but resolved to nothing (stale
+     * path, unindexed file) or to too many files (bare `+page.svelte`). Stripped
+     * from the query — their fragments could only mint junk matches — and
+     * surfaced to the agent so the miss is visible instead of silent.
+     */
+    unresolvedPathSpans: string[];
+}
+/**
+ * Cheap pre-gate so callers only fetch the indexed file list when the query
+ * could possibly contain a path: a slash, a dot-extension-shaped tail
+ * (`chat-manager.ts`), or a hyphen-joined word (`background-image-table` —
+ * kebab files are named WITHOUT their extension more often than with, so the
+ * shape must open the gate on its own). Extensions cap at 8 chars, which
+ * keeps `Class.method` spans (`app.isPackaged`) from qualifying; the kebab
+ * alternative requires clean non-word boundaries, which keeps `--flags` and
+ * snake_case-with-a-dash hybrids from firing it.
+ */
+export declare function queryMightContainPaths(query: string): boolean;
+export declare function extractQueryPaths(query: string, indexedPaths: readonly string[], opts?: {
+    maxPins?: number;
+    maxMatchesPerSpan?: number;
+}): QueryPathExtraction;
+//# sourceMappingURL=query-paths.d.ts.map

package/dist/search/query-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-paths.d.ts","sourceRoot":"","sources":["../../src/search/query-paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;OAKG;IACH,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAI7D;AAmID,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,mBAAmB,CA8FrB"}