@descryy/runtime-graph-correlator 0.0.0

package/dist/symbol.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Resolving source-mapped evidence (a stack frame or backend log line naming
+ * a file + symbol) to the `FUNCTION`/`CLASS` node it came from.
+ *
+ * Unlike `endpoint.ts`, this *is* a "wrong repository" risk: `FUNCTION` and
+ * `CLASS` are repo-scoped (DEC-054), and a runtime session that merges more
+ * than one repository into one store (frontend + backend, to trace across
+ * them — DEC-228) can hold two same-named, same-relative-path symbols that
+ * belong to different repositories. `repo` is therefore required here, not
+ * optional — there is no honest default for it, and guessing one is exactly
+ * the failure `resolveOneNode` (descry-core's own MCP lookup) refuses to
+ * make. This function inherits that discipline rather than reimplementing
+ * it differently: return every match, never pick one by heuristic, refuse
+ * ambiguity to the caller instead of resolving it silently.
+ *
+ * `line`, when the caller has one (a stack frame almost always does), is a
+ * second, independent check after name+file+repo resolve to exactly one
+ * node: does the evidence's own claimed line actually fall inside that
+ * node's range? A source map can point at the right *file* and even the
+ * right *function name* while still landing on a stale line — a stripped
+ * build, a moved function whose body shifted, a webpack virtual path that
+ * resolves near but not into the real range. Name+file+repo agreeing is not
+ * the same claim as the line agreeing, so a mismatch is its own outcome
+ * (`line-mismatch`) rather than a silent `resolved` that hides a real
+ * discrepancy, or a `not-found` that discards a symbol that plainly exists.
+ */
+import type { IRNode } from "@descryy/ir";
+import { type SqlDriver } from "@descryy/core";
+export type SymbolResolution = {
+    readonly outcome: "resolved";
+    readonly node: IRNode;
+} | {
+    readonly outcome: "not-found";
+    readonly reason: string;
+} | {
+    readonly outcome: "ambiguous";
+    readonly candidates: readonly IRNode[];
+    readonly reason: string;
+} | {
+    readonly outcome: "line-mismatch";
+    readonly node: IRNode;
+    readonly reason: string;
+};
+export declare function resolveSymbolNode(driver: SqlDriver, location: {
+    readonly file: string;
+    readonly symbolName: string;
+    readonly line?: number;
+}, repo: string, 
+/**
+ * `cwd`: the directory the process that produced `location.file` was
+ * actually launched in. Pass it whenever the caller knows it and the
+ * evidence's runtime is one that echoes its invocation argument verbatim
+ * (RT-113: Ruby) -- omitting it is not "safer", it is the passthrough
+ * behaviour every other caller already relies on for an already
+ * repo-relative path.
+ */
+options?: {
+    readonly repoRoot?: string;
+    readonly cwd?: string;
+}): SymbolResolution;
+/**
+ * `resolveSymbolNode`, tried across every repo the caller knows about,
+ * for the evidence shape RT-008 names but `resolveSymbolNode` itself
+ * cannot serve: a signal with **no known scope at all** (a raw log line
+ * naming a symbol, no service/repo hint), arriving into a session that
+ * spans more than one repository. `resolveSymbolNode` already refuses
+ * ambiguity *within* one repo by requiring `repo` as a mandatory parameter
+ * — this function is the layer above that: trying repos in sequence and
+ * keeping the first hit would smuggle a guess back in through the one door
+ * `resolveSymbolNode` closed, so a match in more than one repo is refused
+ * here too, naming every repo that matched.
+ *
+ * Negative control #1 (`next_tasks.md` T6): two repos, identically-named
+ * symbol at the same relative path, no scope given — must refuse, not pick
+ * either.
+ */
+export type CrossRepoSymbolResolution = {
+    readonly outcome: "resolved";
+    readonly repo: string;
+    readonly node: IRNode;
+} | {
+    readonly outcome: "not-found";
+    readonly reason: string;
+} | {
+    readonly outcome: "cross-repo-ambiguous";
+    readonly matches: readonly {
+        readonly repo: string;
+        readonly node: IRNode;
+    }[];
+    readonly reason: string;
+};
+export declare function resolveSymbolAcrossRepos(driver: SqlDriver, location: {
+    readonly file: string;
+    readonly symbolName: string;
+    readonly line?: number;
+}, knownRepos: readonly string[], options?: {
+    readonly repoRoot?: string;
+    readonly cwd?: string;
+}): CrossRepoSymbolResolution;
+/**
+ * The **coarser** answer: which `MODULE` node is declared in the file this
+ * evidence named.
+ *
+ * §10 asks the runtime to correlate evidence to each graph node type where
+ * applicable. Measured across `descry-adapters` rather than assumed, the
+ * picture for the file-shaped types is:
+ *
+ * | type | producers | so |
+ * | --- | --- | --- |
+ * | `MODULE` | 10 of 15 adapters | correlatable, and this is it |
+ * | `FILE` | **zero** | nothing to correlate to, on any repository |
+ *
+ * **`FILE` is not a gap in this file.** No shipped adapter emits one —
+ * `descry-core`'s `capabilities/preconditions.ts` records the same fact and
+ * exists because three static checks read `nodesOfType("FILE")` and were
+ * dead on every real repository while 48 tests stayed green. A runtime
+ * resolver targeting `FILE` would reproduce that exactly: a function that
+ * always returns `not-found`, indistinguishable from a clean answer.
+ *
+ * ## Why this is a separate function, not a fallback inside `resolveSymbolNode`
+ *
+ * A caller must **ask** for the coarser answer. `resolveSymbolNode` silently
+ * degrading to a module when the symbol did not resolve would be the
+ * honest-degradation rule broken in the one place it matters most: the
+ * refusal would disappear, and a consumer would see a resolution where the
+ * truth is "we could not find the function, here is the file it claims to be
+ * in." Two outcomes that mean different things must not arrive through the
+ * same door.
+ *
+ * ## The outcome is `module-level`, never `resolved`
+ *
+ * Following RT-055's `sole-structural-caller`: the vocabulary carries the
+ * claim's strength at the type level, so a consumer cannot treat a
+ * file-granularity answer as a symbol-granularity one by writing
+ * `outcome === "resolved"`. This matters for the resolution cap — a finding
+ * resting on a module-level correlation knows *which file* failed and does
+ * not know *which function*, and those are different findings.
+ */
+export type ModuleResolution = {
+    readonly outcome: "module-level";
+    readonly node: IRNode;
+} | {
+    readonly outcome: "not-found";
+    readonly reason: string;
+} | {
+    readonly outcome: "ambiguous";
+    readonly candidates: readonly IRNode[];
+    readonly reason: string;
+};
+export declare function resolveContainingModule(driver: SqlDriver, file: string, repo: string, 
+/** See `resolveSymbolNode`'s `cwd` -- same translation, same opt-in. */
+options?: {
+    readonly repoRoot?: string;
+    readonly cwd?: string;
+}): ModuleResolution;
+/**
+ * Resolving an **observed** test — a `test:pass`/`test:fail` event from a real
+ * runner, carrying the test's own name, file and line — to the `TEST_CASE`
+ * node an adapter minted for it.
+ *
+ * This is the join that lets a failing test stop being a parallel silo. Once
+ * the observed test is a graph node, the `TESTS` edges already leaving that
+ * node answer "what does this test cover" with **no runtime guessing at all**
+ * — the subject was resolved statically, by an adapter, at index time. The
+ * runtime's job is to identify the node, not to infer the relationship.
+ *
+ * ## Why the fifth outcome exists, and the measurement behind it
+ *
+ * Counted across `descry-adapters` rather than assumed, by looking for actual
+ * node construction (`type: "TEST_CASE"`) rather than references to the
+ * string — six of the ten language adapters mention `TEST_CASE` while
+ * constructing none, because they use it for the `TESTS` *edge* and for
+ * container checks:
+ *
+ * | | adapters |
+ * | --- | --- |
+ * | construct `TEST_CASE` nodes | 4 |
+ * | mention it, construct none | 6 |
+ *
+ * So a four-outcome resolver copied from `resolveSymbolNode` would return
+ * `not-found` forever for the six, and `not-found` already means *"this graph
+ * has no such node"* — which a consumer reads as "that test isn't indexed."
+ * The truth is that nothing was ever going to index it. That is the same
+ * always-returns-not-found shape that killed the `FILE` resolver idea one
+ * function above, displaced rather than avoided, and it is RT-060's
+ * producer-versus-consumer attribution restated: a refusal has to say **whose**
+ * gap it is.
+ *
+ * ## `producer-emitted-none` claims exactly what was measured, and no more
+ *
+ * The name is not `producer-does-not-emit`, because this function cannot
+ * observe an adapter — it observes a store. Zero `TEST_CASE` nodes in a
+ * language admits two readings: no adapter for that language emits them, or
+ * this store simply holds no tests written in it. **Both are producer-side,
+ * and neither is "your test is missing"** — which is the whole distinction a
+ * consumer needs. The reason string carries the disjunction instead of the
+ * outcome name resolving it by fiat.
+ *
+ * And when the scan truncates, this outcome is **withheld**: a set-property
+ * question answered over a silently truncated set is a fact computed from a
+ * sample, which is the warning `nodesOfType` carries in its own doc comment.
+ * A truncated scan that found nothing degrades to `not-found` naming the
+ * truncation, never to a confident claim about a producer.
+ *
+ * ## This reads `language`; it does not branch on one
+ *
+ * `IRNode.language` is provenance and must never be branched on above the IR
+ * boundary. Nothing here compares it to a literal — no language name appears
+ * in this file. It groups by the value the graph itself supplied, the same way
+ * `findNodes` narrows by a `repo` string it was handed. A hardcoded set of
+ * "languages whose adapters emit TEST_CASE" would have been the violation, and
+ * it would also have gone stale the first time an adapter started emitting.
+ */
+export type TestCaseResolution = {
+    readonly outcome: "resolved";
+    readonly node: IRNode;
+} | {
+    readonly outcome: "not-found";
+    readonly reason: string;
+} | {
+    readonly outcome: "ambiguous";
+    readonly candidates: readonly IRNode[];
+    readonly reason: string;
+} | {
+    readonly outcome: "line-mismatch";
+    readonly node: IRNode;
+    readonly reason: string;
+} | {
+    readonly outcome: "producer-emitted-none";
+    readonly language: string | null;
+    readonly reason: string;
+};
+export declare function resolveTestCaseNode(driver: SqlDriver, location: {
+    readonly file: string;
+    readonly testName: string;
+    readonly line?: number;
+}, repo: string, 
+/** `cwd`: see `resolveSymbolNode`'s doc -- same translation, same opt-in. */
+options?: {
+    readonly repoRoot?: string;
+    readonly cwd?: string;
+    readonly producerScanLimit?: number;
+}): TestCaseResolution;
+//# sourceMappingURL=symbol.d.ts.map

package/dist/symbol.d.ts.map

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

package/dist/symbol.js

@@ -0,0 +1,344 @@
+/**
+ * Resolving source-mapped evidence (a stack frame or backend log line naming
+ * a file + symbol) to the `FUNCTION`/`CLASS` node it came from.
+ *
+ * Unlike `endpoint.ts`, this *is* a "wrong repository" risk: `FUNCTION` and
+ * `CLASS` are repo-scoped (DEC-054), and a runtime session that merges more
+ * than one repository into one store (frontend + backend, to trace across
+ * them — DEC-228) can hold two same-named, same-relative-path symbols that
+ * belong to different repositories. `repo` is therefore required here, not
+ * optional — there is no honest default for it, and guessing one is exactly
+ * the failure `resolveOneNode` (descry-core's own MCP lookup) refuses to
+ * make. This function inherits that discipline rather than reimplementing
+ * it differently: return every match, never pick one by heuristic, refuse
+ * ambiguity to the caller instead of resolving it silently.
+ *
+ * `line`, when the caller has one (a stack frame almost always does), is a
+ * second, independent check after name+file+repo resolve to exactly one
+ * node: does the evidence's own claimed line actually fall inside that
+ * node's range? A source map can point at the right *file* and even the
+ * right *function name* while still landing on a stale line — a stripped
+ * build, a moved function whose body shifted, a webpack virtual path that
+ * resolves near but not into the real range. Name+file+repo agreeing is not
+ * the same claim as the line agreeing, so a mismatch is its own outcome
+ * (`line-mismatch`) rather than a silent `resolved` that hides a real
+ * discrepancy, or a `not-found` that discards a symbol that plainly exists.
+ */
+import { isAbsolute, relative, resolve as resolvePath } from "node:path";
+import { findNodes, nodesOfType } from "@descryy/core";
+const SYMBOL_NODE_TYPES = new Set(["FUNCTION", "CLASS"]);
+/**
+ * **Runtime evidence and the graph do not speak the same path language, and
+ * they should not.** A stack frame names an absolute on-disk path — that is
+ * what was actually observed, and rewriting it at capture time would
+ * destroy the observation. Graph nodes carry repo-relative paths, because a
+ * path-dependent identity churns on every checkout location. Something has
+ * to translate, and this is the function whose entire job is mapping
+ * runtime evidence onto graph entities, so it translates here.
+ *
+ * **Found by the continuous-chain test, and only by it.** Every earlier
+ * test supplied a path in whichever convention it happened to need — the
+ * vertical slice pre-relativised with its own helper, the collector tests
+ * never resolved to a node — so the two halves each looked right and the
+ * seam between them had never been crossed. The first run that crossed it
+ * failed with `not-found` on a symbol that plainly exists.
+ *
+ * **The old failure was worse than a failure: it was a misleading one.**
+ * An absolute path simply matched nothing, and the refusal read `No
+ * FUNCTION/CLASS node named "deleteInvoice" in
+ * "/home/.../server.mjs"` — which a reader takes as "that symbol is not in
+ * the graph" when the truth is "you handed me a path in the other
+ * coordinate system." Both refusals below now say which of the two it is.
+ *
+ * Relativising is exact, never a guess: the path must actually live under
+ * `repoRoot`, and a path outside it is a **different repository's file**,
+ * reported as such. Matching on basename instead would be RT-031's
+ * identity-proxy error — `server.mjs` exists in both fixture repos.
+ */
+/**
+ * Absolute observed path → repo-relative graph path, or a refusal saying
+ * which of the two coordinate systems went wrong.
+ *
+ * **Shared rather than copied**, because both resolvers in this file must
+ * translate identically. A second copy would hold in one of them; measured
+ * elsewhere in this project at a two-week silent drift, and here the drift
+ * would be between "we found the symbol" and "we found the module in the
+ * same file", which no test comparing only outcomes would notice.
+ *
+ * **A third coordinate system, alongside absolute and repo-relative:
+ * relative-to-whatever-cwd-the-process-was-launched-in.** RT-113 measured it
+ * against Ruby — a backtrace prints the path exactly as invoked, never
+ * normalized — but nothing about the fact is Ruby-specific: any runtime that
+ * echoes its own invocation argument verbatim produces the same shape, and
+ * this function cannot tell that class of relative path from an
+ * already-repo-relative one by looking at it. It can only be told, by a
+ * caller that knows the directory the process actually ran in. `cwd` is that
+ * signal: passing it is how a caller opts a relative path into this
+ * resolution instead of the passthrough below, so every existing caller that
+ * never supplies it keeps exactly its old behaviour (`resolveSymbolNode: a
+ * relative path still works unchanged`, `symbol.test.ts`). When given, a
+ * relative path is resolved against it into an absolute path and handed to
+ * the same repoRoot-relativisation the absolute branch already does below —
+ * one coordinate translation, not two.
+ */
+function toRepoRelative(file, repo, repoRoot, cwd) {
+    if (!isAbsolute(file)) {
+        if (cwd === undefined) {
+            // A leading `./` is not a second repository's file and not a missing
+            // symbol -- it is `rustc`'s own path language. Compiled with a relative
+            // source argument (`rustc -g -o bin self-failing-server.rs`, exactly
+            // what a managed spawn does), the panic header embeds
+            // `./self-failing-server.rs` verbatim; `discover()` (adapter-common)
+            // never produces a `./`-prefixed path, so the two would otherwise agree
+            // on everything but this one cosmetic prefix and report `not-found`.
+            // Stripped unconditionally: a leading `./` never carries identity,
+            // unlike `..` which genuinely means "outside" and is left alone.
+            //
+            // No `cwd` known means no way to distinguish "already repo-relative"
+            // from "relative to some other, unrecorded base" -- passthrough is the
+            // existing, deliberately narrow default, not a guess that this path is
+            // correct.
+            return { ok: true, file: file.startsWith("./") ? file.slice(2) : file };
+        }
+        file = resolvePath(cwd, file);
+    }
+    if (repoRoot === undefined) {
+        return {
+            ok: false,
+            reason: `Evidence named the absolute path "${file}", but graph nodes carry repo-relative paths. ` +
+                `Pass \`repoRoot\` so this can be translated exactly. Reported rather than searched for a ` +
+                `suffix match, which would resolve the wrong repository's identically-named file.`,
+        };
+    }
+    const relativePath = relative(repoRoot, file);
+    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+        return {
+            ok: false,
+            reason: `Evidence named "${file}", which is not under repo "${repo}"'s root "${repoRoot}" — ` +
+                `it belongs to a different repository, not to a missing symbol in this one.`,
+        };
+    }
+    return { ok: true, file: relativePath };
+}
+export function resolveSymbolNode(driver, location, repo, 
+/**
+ * `cwd`: the directory the process that produced `location.file` was
+ * actually launched in. Pass it whenever the caller knows it and the
+ * evidence's runtime is one that echoes its invocation argument verbatim
+ * (RT-113: Ruby) -- omitting it is not "safer", it is the passthrough
+ * behaviour every other caller already relies on for an already
+ * repo-relative path.
+ */
+options = {}) {
+    const translated = toRepoRelative(location.file, repo, options.repoRoot, options.cwd);
+    if (!translated.ok)
+        return { outcome: "not-found", reason: translated.reason };
+    const file = translated.file;
+    const matches = findNodes(driver, {
+        name: location.symbolName,
+        file,
+        repo,
+        limit: 10,
+    }).filter((n) => SYMBOL_NODE_TYPES.has(n.type));
+    if (matches.length === 0) {
+        return {
+            outcome: "not-found",
+            reason: `No FUNCTION/CLASS node named "${location.symbolName}" in "${file}" within repo ` +
+                `"${repo}". This does not mean it does not exist — it may mean no adapter read it, or the ` +
+                "graph predates it.",
+        };
+    }
+    if (matches.length > 1) {
+        return {
+            outcome: "ambiguous",
+            candidates: matches,
+            reason: `${matches.length} nodes named "${location.symbolName}" exist in "${file}" within ` +
+                `repo "${repo}" — ${matches.map((n) => n.type).join(", ")}. Picking one by a heuristic would ` +
+                "be reasoning confidently about a symbol the evidence did not actually distinguish.",
+        };
+    }
+    const node = matches[0];
+    // `null` joins `undefined` here deliberately: a frame that carried no
+    // line (a JVM `Unknown Source` frame) has nothing to check the range
+    // against, and treating "no line" as a mismatch would reject a correct
+    // name-and-file match on the strength of information nobody captured.
+    if (location.line !== undefined && location.line !== null && node.range !== null) {
+        const { startLine, endLine } = node.range;
+        if (location.line < startLine || location.line > endLine) {
+            return {
+                outcome: "line-mismatch",
+                node,
+                reason: `Evidence claims line ${location.line}, but "${location.symbolName}" spans lines ` +
+                    `${startLine}-${endLine}. Name and file agree; the line does not — treat the source ` +
+                    "location as unreliable rather than silently trusting the name match.",
+            };
+        }
+    }
+    return { outcome: "resolved", node };
+}
+export function resolveSymbolAcrossRepos(driver, location, knownRepos, options = {}) {
+    const resolved = [];
+    for (const repo of knownRepos) {
+        const result = resolveSymbolNode(driver, location, repo, options);
+        // Only a clean `resolved` counts as a match here -- `ambiguous` (two
+        // symbols within that one repo) and `line-mismatch` are that repo's own
+        // refusal, not a hit to compare against the other repos' results, and
+        // folding them in would understate the ambiguity rather than report it.
+        if (result.outcome === "resolved")
+            resolved.push({ repo, node: result.node });
+    }
+    if (resolved.length === 0) {
+        return {
+            outcome: "not-found",
+            reason: `No FUNCTION/CLASS node named "${location.symbolName}" in "${location.file}" was found in any ` +
+                `of the ${knownRepos.length} known repositories (${knownRepos.join(", ") || "none"}).`,
+        };
+    }
+    if (resolved.length > 1) {
+        return {
+            outcome: "cross-repo-ambiguous",
+            matches: resolved,
+            reason: `"${location.symbolName}" in "${location.file}" resolved in ${resolved.length} different ` +
+                `repositories (${resolved.map((m) => m.repo).join(", ")}), and this evidence carries no repo ` +
+                "scope to pick one. Trying repos in sequence and keeping the first hit would be a guess; " +
+                "refused instead.",
+        };
+    }
+    return { outcome: "resolved", repo: resolved[0].repo, node: resolved[0].node };
+}
+export function resolveContainingModule(driver, file, repo, 
+/** See `resolveSymbolNode`'s `cwd` -- same translation, same opt-in. */
+options = {}) {
+    const translated = toRepoRelative(file, repo, options.repoRoot, options.cwd);
+    if (!translated.ok)
+        return { outcome: "not-found", reason: translated.reason };
+    const relativeFile = translated.file;
+    const matches = findNodes(driver, { file: relativeFile, repo, limit: 10 }).filter((n) => n.type === "MODULE");
+    if (matches.length === 0) {
+        return {
+            outcome: "not-found",
+            reason: `No MODULE node is declared in "${relativeFile}" within repo "${repo}". Either no adapter read ` +
+                "that file, or the adapter that read it does not emit MODULE — ten of fifteen do, so the " +
+                "absence is a producer question, not evidence that the file is uninteresting.",
+        };
+    }
+    if (matches.length > 1) {
+        // Two modules declared in one file is legitimate in several languages
+        // (Ruby, C#, Python's nested scopes) — the observed file does not say
+        // which one the frame was inside, and neither does a line, since module
+        // ranges routinely nest. Refused rather than ranked.
+        return {
+            outcome: "ambiguous",
+            candidates: matches,
+            reason: `${matches.length} MODULE nodes are declared in "${relativeFile}" within repo "${repo}" — ` +
+                `${matches.map((n) => n.name).join(", ")}. A file-level observation cannot say which, and ` +
+                "picking the outermost or the first would be a guess dressed as a coarse answer.",
+        };
+    }
+    return { outcome: "module-level", node: matches[0] };
+}
+/** Cap on the `TEST_CASE` scan backing `producer-emitted-none`. Truncation withholds the claim. */
+const PRODUCER_SCAN_LIMIT = 5000;
+export function resolveTestCaseNode(driver, location, repo, 
+/** `cwd`: see `resolveSymbolNode`'s doc -- same translation, same opt-in. */
+options = {}) {
+    const translated = toRepoRelative(location.file, repo, options.repoRoot, options.cwd);
+    if (!translated.ok)
+        return { outcome: "not-found", reason: translated.reason };
+    const file = translated.file;
+    const matches = findNodes(driver, { name: location.testName, file, repo, limit: 10 }).filter((n) => n.type === "TEST_CASE");
+    if (matches.length > 1) {
+        // Two tests of the same name in one file is ordinary — `describe` blocks
+        // nest, and several runners scope a name to its block rather than to the
+        // file. The observed event carries a line, but test ranges nest just as
+        // module ranges do, so the innermost is not reliably the right one.
+        // Refused rather than ranked, exactly as above.
+        return {
+            outcome: "ambiguous",
+            candidates: matches,
+            reason: `${matches.length} TEST_CASE nodes named "${location.testName}" exist in "${file}" within ` +
+                `repo "${repo}". Test names repeat across nested blocks, and picking by line would rank ` +
+                "nested ranges — a guess dressed as a resolution.",
+        };
+    }
+    if (matches.length === 1) {
+        const node = matches[0];
+        if (location.line !== undefined && location.line !== null && node.range !== null) {
+            const { startLine, endLine } = node.range;
+            if (location.line < startLine || location.line > endLine) {
+                return {
+                    outcome: "line-mismatch",
+                    node,
+                    reason: `The runner reported line ${location.line}, but TEST_CASE "${location.testName}" spans ` +
+                        `lines ${startLine}-${endLine}. Name and file agree; the line does not — the graph is ` +
+                        "likely older than the file, so treat the node as identified but the position as stale.",
+                };
+            }
+        }
+        return { outcome: "resolved", node };
+    }
+    return explainMissingTestCase(driver, file, repo, location.testName, options.producerScanLimit);
+}
+/**
+ * Why nothing matched — the part that has to distinguish four genuinely
+ * different situations that all present as an empty result set.
+ *
+ * Kept separate from the resolver so the resolver reads as one decision, and
+ * so this can be exercised directly: three of the four branches need a store
+ * shaped a particular way, and reaching them through the happy path would
+ * mean every test also depended on name matching working.
+ */
+function explainMissingTestCase(driver, file, repo, testName, scanLimit) {
+    const inFile = findNodes(driver, { file, repo, limit: 200 });
+    // (1) Nothing at all from this file. No adapter read it — an excluded path,
+    // an unsupported extension, a file newer than the graph. Reporting a
+    // producer claim here would be wrong in a specific way: it would blame the
+    // language when the file was never opened.
+    if (inFile.length === 0) {
+        return {
+            outcome: "not-found",
+            reason: `No node of any type was produced from "${file}" within repo "${repo}", so the file itself ` +
+                "was never read — not excluded from test extraction, excluded from parsing. Check the " +
+                "adapter's file selection before concluding anything about test support.",
+        };
+    }
+    const language = inFile.find((n) => n.language !== null)?.language ?? null;
+    const limit = scanLimit ?? PRODUCER_SCAN_LIMIT;
+    const { nodes: testCases, truncated } = nodesOfType(driver, "TEST_CASE", limit);
+    const sameLanguage = testCases.filter((n) => n.language === language);
+    if (sameLanguage.length === 0) {
+        // (2) The scan hit its cap, so "none" was measured over a sample. The
+        // producer claim is withheld rather than made cheaply.
+        if (truncated) {
+            return {
+                outcome: "not-found",
+                reason: `No TEST_CASE node named "${testName}" in "${file}". A scan for TEST_CASE nodes of the ` +
+                    `same provenance found none, but the scan truncated at ${limit} rows — that is a sample, ` +
+                    "not the set, so no claim about the producer is made from it. Raise `producerScanLimit`.",
+            };
+        }
+        // (3) The whole store holds no TEST_CASE node of this provenance. Not a
+        // consumer-side miss, and the reason says so without deciding which of
+        // the two producer-side readings applies.
+        return {
+            outcome: "producer-emitted-none",
+            language,
+            reason: `This store holds no TEST_CASE node of the same provenance as "${file}" — ${testCases.length} ` +
+                "TEST_CASE nodes exist in total, none of them from this language. Either no adapter for it " +
+                "emits TEST_CASE, or nothing indexed here is written in it. Both are producer-side: the " +
+                `runner observed "${testName}" and the graph was never going to contain it, which is not the ` +
+                "same as the test being absent from a graph that could have held it.",
+        };
+    }
+    // (4) The producer does emit for this provenance, and this particular test
+    // still is not there — a real consumer-side miss, and the only branch where
+    // "the graph does not have your test" is the honest sentence.
+    return {
+        outcome: "not-found",
+        reason: `No TEST_CASE node named "${testName}" in "${file}" within repo "${repo}", though ` +
+            `${sameLanguage.length} TEST_CASE nodes of the same provenance exist elsewhere in this store — ` +
+            "so the producer does emit them and this one genuinely is not indexed. A renamed test, a " +
+            "dynamically generated name, or a graph older than the file.",
+    };
+}
+//# sourceMappingURL=symbol.js.map

package/dist/symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.js","sourceRoot":"","sources":["../src/symbol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AAGzE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAkB,MAAM,eAAe,CAAC;AAQvE,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAS,cAAc,CACrB,IAAY,EACZ,IAAY,EACZ,QAA4B,EAC5B,GAAuB;IAEvB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,qEAAqE;YACrE,wEAAwE;YACxE,qEAAqE;YACrE,sDAAsD;YACtD,qEAAqE;YACrE,wEAAwE;YACxE,qEAAqE;YACrE,mEAAmE;YACnE,iEAAiE;YACjE,EAAE;YACF,qEAAqE;YACrE,uEAAuE;YACvE,uEAAuE;YACvE,WAAW;YACX,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC1E,CAAC;QACD,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IACD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EACJ,qCAAqC,IAAI,gDAAgD;gBACzF,2FAA2F;gBAC3F,kFAAkF;SACrF,CAAC;IACJ,CAAC;IACD,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC9C,IAAI,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QAC9D,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EACJ,mBAAmB,IAAI,+BAA+B,IAAI,aAAa,QAAQ,MAAM;gBACrF,4EAA4E;SAC/E,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,MAAiB,EACjB,QAAwF,EACxF,IAAY;AACZ;;;;;;;GAOG;AACH,UAAiE,EAAE;IAEnE,MAAM,UAAU,GAAG,cAAc,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACtF,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;IAC/E,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;IAE7B,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE;QAChC,IAAI,EAAE,QAAQ,CAAC,UAAU;QACzB,IAAI;QACJ,IAAI;QACJ,KAAK,EAAE,EAAE;KACV,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAEhD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,MAAM,EACJ,iCAAiC,QAAQ,CAAC,UAAU,SAAS,IAAI,gBAAgB;gBACjF,IAAI,IAAI,mFAAmF;gBAC3F,oBAAoB;SACvB,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,UAAU,EAAE,OAAO;YACnB,MAAM,EACJ,GAAG,OAAO,CAAC,MAAM,iBAAiB,QAAQ,CAAC,UAAU,eAAe,IAAI,WAAW;gBACnF,SAAS,IAAI,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,qCAAqC;gBAC9F,oFAAoF;SACvF,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC;IAEzB,sEAAsE;IACtE,qEAAqE;IACrE,uEAAuE;IACvE,sEAAsE;IACtE,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QACjF,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAC1C,IAAI,QAAQ,CAAC,IAAI,GAAG,SAAS,IAAI,QAAQ,CAAC,IAAI,GAAG,OAAO,EAAE,CAAC;YACzD,OAAO;gBACL,OAAO,EAAE,eAAe;gBACxB,IAAI;gBACJ,MAAM,EACJ,wBAAwB,QAAQ,CAAC,IAAI,UAAU,QAAQ,CAAC,UAAU,gBAAgB;oBAClF,GAAG,SAAS,IAAI,OAAO,8DAA8D;oBACrF,sEAAsE;aACzE,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACvC,CAAC;AA2BD,MAAM,UAAU,wBAAwB,CACtC,MAAiB,EACjB,QAAwF,EACxF,UAA6B,EAC7B,UAAiE,EAAE;IAEnE,MAAM,QAAQ,GAAqC,EAAE,CAAC;IACtD,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAClE,qEAAqE;QACrE,wEAAwE;QACxE,sEAAsE;QACtE,wEAAwE;QACxE,IAAI,MAAM,CAAC,OAAO,KAAK,UAAU;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAChF,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,MAAM,EACJ,iCAAiC,QAAQ,CAAC,UAAU,SAAS,QAAQ,CAAC,IAAI,qBAAqB;gBAC/F,UAAU,UAAU,CAAC,MAAM,wBAAwB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,IAAI;SACzF,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO;YACL,OAAO,EAAE,sBAAsB;YAC/B,OAAO,EAAE,QAAQ;YACjB,MAAM,EACJ,IAAI,QAAQ,CAAC,UAAU,SAAS,QAAQ,CAAC,IAAI,iBAAiB,QAAQ,CAAC,MAAM,aAAa;gBAC1F,iBAAiB,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,uCAAuC;gBAC9F,0FAA0F;gBAC1F,kBAAkB;SACrB,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAC;AACnF,CAAC;AA8CD,MAAM,UAAU,uBAAuB,CACrC,MAAiB,EACjB,IAAY,EACZ,IAAY;AACZ,wEAAwE;AACxE,UAAiE,EAAE;IAEnE,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7E,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;IAC/E,MAAM,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC;IAErC,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IAE9G,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,MAAM,EACJ,kCAAkC,YAAY,kBAAkB,IAAI,4BAA4B;gBAChG,0FAA0F;gBAC1F,8EAA8E;SACjF,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,sEAAsE;QACtE,sEAAsE;QACtE,wEAAwE;QACxE,qDAAqD;QACrD,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,UAAU,EAAE,OAAO;YACnB,MAAM,EACJ,GAAG,OAAO,CAAC,MAAM,kCAAkC,YAAY,kBAAkB,IAAI,MAAM;gBAC3F,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,mDAAmD;gBAC3F,iFAAiF;SACpF,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAE,EAAE,CAAC;AACxD,CAAC;AAmED,mGAAmG;AACnG,MAAM,mBAAmB,GAAG,IAAI,CAAC;AAEjC,MAAM,UAAU,mBAAmB,CACjC,MAAiB,EACjB,QAAsF,EACtF,IAAY;AACZ,6EAA6E;AAC7E,UAAsG,EAAE;IAExG,MAAM,UAAU,GAAG,cAAc,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACtF,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;IAC/E,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;IAE7B,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,CAC1F,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAC9B,CAAC;IAEF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,oEAAoE;QACpE,gDAAgD;QAChD,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,UAAU,EAAE,OAAO;YACnB,MAAM,EACJ,GAAG,OAAO,CAAC,MAAM,2BAA2B,QAAQ,CAAC,QAAQ,eAAe,IAAI,WAAW;gBAC3F,SAAS,IAAI,4EAA4E;gBACzF,kDAAkD;SACrD,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC;QACzB,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACjF,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;YAC1C,IAAI,QAAQ,CAAC,IAAI,GAAG,SAAS,IAAI,QAAQ,CAAC,IAAI,GAAG,OAAO,EAAE,CAAC;gBACzD,OAAO;oBACL,OAAO,EAAE,eAAe;oBACxB,IAAI;oBACJ,MAAM,EACJ,4BAA4B,QAAQ,CAAC,IAAI,oBAAoB,QAAQ,CAAC,QAAQ,UAAU;wBACxF,SAAS,SAAS,IAAI,OAAO,0DAA0D;wBACvF,wFAAwF;iBAC3F,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;IACvC,CAAC;IAED,OAAO,sBAAsB,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;AAClG,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,sBAAsB,CAC7B,MAAiB,EACjB,IAAY,EACZ,IAAY,EACZ,QAAgB,EAChB,SAA6B;IAE7B,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAE7D,4EAA4E;IAC5E,qEAAqE;IACrE,2EAA2E;IAC3E,2CAA2C;IAC3C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO;YACL,OAAO,EAAE,WAAW;YACpB,MAAM,EACJ,0CAA0C,IAAI,kBAAkB,IAAI,wBAAwB;gBAC5F,uFAAuF;gBACvF,yEAAyE;SAC5E,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,EAAE,QAAQ,IAAI,IAAI,CAAC;IAC3E,MAAM,KAAK,GAAG,SAAS,IAAI,mBAAmB,CAAC;IAC/C,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAChF,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;IAEtE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,sEAAsE;QACtE,uDAAuD;QACvD,IAAI,SAAS,EAAE,CAAC;YACd,OAAO;gBACL,OAAO,EAAE,WAAW;gBACpB,MAAM,EACJ,4BAA4B,QAAQ,SAAS,IAAI,uCAAuC;oBACxF,yDAAyD,KAAK,4BAA4B;oBAC1F,yFAAyF;aAC5F,CAAC;QACJ,CAAC;QACD,wEAAwE;QACxE,uEAAuE;QACvE,0CAA0C;QAC1C,OAAO;YACL,OAAO,EAAE,uBAAuB;YAChC,QAAQ;YACR,MAAM,EACJ,iEAAiE,IAAI,OAAO,SAAS,CAAC,MAAM,GAAG;gBAC/F,4FAA4F;gBAC5F,yFAAyF;gBACzF,oBAAoB,QAAQ,kEAAkE;gBAC9F,qEAAqE;SACxE,CAAC;IACJ,CAAC;IAED,2EAA2E;IAC3E,4EAA4E;IAC5E,8DAA8D;IAC9D,OAAO;QACL,OAAO,EAAE,WAAW;QACpB,MAAM,EACJ,4BAA4B,QAAQ,SAAS,IAAI,kBAAkB,IAAI,YAAY;YACnF,GAAG,YAAY,CAAC,MAAM,0EAA0E;YAChG,0FAA0F;YAC1F,6DAA6D;KAChE,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@descryy/runtime-graph-correlator",
+  "version": "0.0.0",
+  "type": "module",
+  "description": "Resolves runtime evidence to descry-core graph nodes and builds the observed graph path between them. Deliverable of the correlation/graph-integration row — depends on @descryy/runtime-contracts, @descryy/core and @descryy/ir; consumes the graph, does not modify it.",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.5"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "dependencies": {
+    "@descryy/runtime-contracts": "*",
+    "@descryy/core": "^0.1.0",
+    "@descryy/ir": "^0.1.0"
+  }
+}