ucn 4.2.3 → 5.0.2

package/core/semantic-provider.js

@@ -0,0 +1,110 @@
+'use strict';
+
+/**
+ * Optional compiler/LSP semantic-provider contract.
+ *
+ * Portable AST analysis remains available without a provider. Hybrid mode
+ * calls this interface explicitly and must surface `unavailable`,
+ * `unsupported`, or `failed`; callers are never allowed to silently relabel
+ * an AST fallback as provider-backed evidence.
+ */
+
+const PROVIDER_OPERATIONS = Object.freeze([
+    'definitions',
+    'references',
+    'callers',
+    'callees',
+    'types',
+    'diagnostics',
+]);
+
+function createSemanticProvider(spec) {
+    if (!spec?.id) throw new Error('Semantic provider id is required');
+    if (!Array.isArray(spec.languages) || spec.languages.length === 0) {
+        throw new Error(`${spec.id}: at least one language is required`);
+    }
+    const operations = {};
+    for (const operation of PROVIDER_OPERATIONS) {
+        if (typeof spec[operation] === 'function') operations[operation] = spec[operation];
+    }
+    return Object.freeze({
+        id: spec.id,
+        languages: Object.freeze([...spec.languages]),
+        operations: Object.freeze(Object.keys(operations)),
+        prepare: typeof spec.prepare === 'function' ? spec.prepare : async () => null,
+        close: typeof spec.close === 'function' ? spec.close : async () => {},
+        ...operations,
+    });
+}
+
+function validateSemanticProvider(provider) {
+    const failures = [];
+    if (!provider?.id) failures.push('provider id is required');
+    if (!Array.isArray(provider?.languages) || provider.languages.length === 0) {
+        failures.push(`${provider?.id || 'provider'}: languages are required`);
+    }
+    if (!Array.isArray(provider?.operations)) {
+        failures.push(`${provider?.id || 'provider'}: operations are required`);
+    } else {
+        for (const operation of provider.operations) {
+            if (!PROVIDER_OPERATIONS.includes(operation)) {
+                failures.push(`${provider.id}: unknown operation ${operation}`);
+            } else if (typeof provider[operation] !== 'function') {
+                failures.push(`${provider.id}: ${operation} is not callable`);
+            }
+        }
+    }
+    if (typeof provider?.prepare !== 'function') {
+        failures.push(`${provider?.id || 'provider'}: prepare() is required`);
+    }
+    if (typeof provider?.close !== 'function') {
+        failures.push(`${provider?.id || 'provider'}: close() is required`);
+    }
+    return failures;
+}
+
+async function invokeSemanticProvider(provider, operation, request) {
+    if (!provider) {
+        return {
+            status: 'unavailable',
+            provider: null,
+            operation,
+            reason: 'no semantic provider configured',
+        };
+    }
+    if (!PROVIDER_OPERATIONS.includes(operation)) {
+        throw new Error(`Unknown semantic provider operation: ${operation}`);
+    }
+    if (!provider.operations.includes(operation) ||
+        typeof provider[operation] !== 'function') {
+        return {
+            status: 'unsupported',
+            provider: provider.id,
+            operation,
+            reason: `${provider.id} does not implement ${operation}`,
+        };
+    }
+    try {
+        const data = await provider[operation](request);
+        return {
+            status: 'ok',
+            provider: provider.id,
+            operation,
+            data,
+        };
+    } catch (error) {
+        return {
+            status: 'failed',
+            provider: provider.id,
+            operation,
+            reason: error.message || String(error),
+        };
+    }
+}
+
+module.exports = {
+    PROVIDER_OPERATIONS,
+    createSemanticProvider,
+    validateSemanticProvider,
+    invokeSemanticProvider,
+};

package/core/stacktrace.js

@@ -276,6 +276,15 @@ function parseStackTrace(index, stackText) {
     // Stack trace patterns for different languages/runtimes
     // Order matters - more specific patterns first
     const patterns = [
+        // .NET: "at Namespace.Type.Method(...) in /src/File.cs:line 42"
+        // and Windows drive-letter paths.
+        { regex: /at\s+([^\s(]+)(?:\([^)]*\))?\s+in\s+(.+?):line\s+(\d+)/, extract: (m) => ({ funcName: m[1].split('.').pop(), file: m[2], line: parseInt(m[3]), col: null }) },
+        // Native sanitizers: "#0 0x... in ns::func /src/file.cpp:42:7"
+        { regex: /#\d+\s+(?:0x[0-9a-f]+\s+)?in\s+([^\s(]+)(?:\([^)]*\))?\s+(.+\.(?:c|cc|cpp|cxx|h|hpp)):(\d+)(?::(\d+))?/i, extract: (m) => ({ funcName: m[1].split('::').pop(), file: m[2], line: parseInt(m[3]), col: m[4] ? parseInt(m[4]) : null }) },
+        // GDB/lldb: "#0 ns::func (...) at src/file.cpp:42"
+        { regex: /#\d+\s+(?:0x[0-9a-f]+\s+in\s+)?([^\s(]+).*?\bat\s+(.+\.(?:c|cc|cpp|cxx|h|hpp)):(\d+)/i, extract: (m) => ({ funcName: m[1].split('::').pop(), file: m[2], line: parseInt(m[3]), col: null }) },
+        // MSVC diagnostics and native exception locations: "src\\file.cpp(42)"
+        { regex: /(.+\.(?:c|cc|cpp|cxx|h|hpp|cs))\((\d+)(?:,(\d+))?\)/i, extract: (m) => ({ file: m[1], line: parseInt(m[2]), col: m[3] ? parseInt(m[3]) : null, funcName: null }) },
         // Rust pre-1.65 panic header: "panicked at 'message', src/main.rs:150:9"
         // MUST precede the Node pattern — its [^():]+ file group has no
         // space/comma guard, so the quoted message glued into the file field
@@ -314,12 +323,22 @@ function parseStackTrace(index, stackText) {
 
     // Track Go function names that appear on a line before the file:line
     let pendingGoFuncName = null;
+    // Rust backtraces likewise split `N: crate::path` and `at file.rs:L:C`
+    // across two physical lines.
+    let pendingRustFuncName = null;
     let skippedFrames = 0;
 
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
 
+        const rustName = trimmed.match(/^\d+:\s+(.+)$/);
+        if (rustName && !/\.rs:\d+/.test(rustName[1])) {
+            pendingRustFuncName = rustName[1].trim();
+            pendingGoFuncName = null;
+            continue;
+        }
+
         // Try each pattern until one matches
         let matched = false;
         for (const pattern of patterns) {
@@ -349,7 +368,12 @@ function parseStackTrace(index, stackText) {
                     if (!extracted.funcName && pendingGoFuncName) {
                         extracted.funcName = pendingGoFuncName;
                     }
+                    if (!extracted.funcName && pendingRustFuncName &&
+                        /\.rs$/i.test(extracted.file)) {
+                        extracted.funcName = pendingRustFuncName;
+                    }
                     pendingGoFuncName = null;
+                    pendingRustFuncName = null;
                     frames.push(createStackFrame(
                         index,
                         extracted.file,
@@ -370,6 +394,7 @@ function parseStackTrace(index, stackText) {
             // unfound-file frames, which render found=false).
             if (/^at\s/.test(trimmed)) skippedFrames++;
             pendingGoFuncName = null; // Reset if line doesn't match any pattern
+            pendingRustFuncName = null;
         }
     }
 

package/core/tracing.js

@@ -23,7 +23,7 @@ const path = require('path');
 const { escapeRegExp, codeUnitCompare, inlineTestRanges, lineInRanges, classDispatchNames } = require('./shared');
 const { isTestFile } = require('./discovery');
 const { getCachedCalls } = require('./callers');
-const { getLanguageModule } = require('../languages');
+const { getLanguageAdapter } = require('../languages');
 
 /**
  * Contract-mode caller expansion for the tree commands. Memoizes the full
@@ -86,20 +86,23 @@ function _aggregateExcluded(treeAccount, raw) {
 function _resolveCallerEntries(index, callers, exclude) {
     const uniqueCallers = new Map();
     for (const c of callers) {
-        if (!c.callerName) continue; // skip module-level code
         if (exclude.length > 0 && !index.matchesFilters(c.relativePath, { exclude })) continue;
-        const callerKey = c.callerStartLine
+        const hasNamedCaller = !!c.callerName;
+        const callerName = c.callerName || '(module/anonymous scope)';
+        const callerStartLine = hasNamedCaller ? c.callerStartLine : c.line;
+        const callerKey = hasNamedCaller && c.callerStartLine
             ? `${c.callerFile}:${c.callerStartLine}`
-            : `${c.callerFile}:${c.callerName}`;
+            : `${c.callerFile}:${callerName}:${callerStartLine || c.line || 0}`;
         if (!uniqueCallers.has(callerKey)) {
             uniqueCallers.set(callerKey, {
-                name: c.callerName,
+                name: callerName,
                 file: c.callerFile,
                 relativePath: c.relativePath,
-                startLine: c.callerStartLine,
-                endLine: c.callerEndLine,
+                startLine: callerStartLine,
+                endLine: hasNamedCaller ? c.callerEndLine : c.line,
                 callSites: 1,
                 reason: c.reason,
+                syntheticScope: !hasNamedCaller,
             });
         } else {
             uniqueCallers.get(callerKey).callSites++;
@@ -121,6 +124,7 @@ function _resolveCallerEntries(index, callers, exclude) {
                 type: 'function'
             };
         }
+        if (caller.syntheticScope) callerDef.syntheticScope = true;
         callerEntries.push({ def: callerDef, callSites: caller.callSites, reason: caller.reason });
     }
 
@@ -195,6 +199,11 @@ function trace(index, name, options = {}) {
             children: []
         };
 
+        // A depth frontier is a node label, not a partially analyzed node.
+        // Do not expose only its unverified callee band while suppressing its
+        // confirmed children; both evidence tiers expand at the same depth.
+        if (currentDepth >= maxDepth) return node;
+
         if (dir === 'down' || dir === 'both') {
             let callees = calleeCache.get(key);
             if (!callees) {
@@ -347,15 +356,18 @@ function blast(index, name, options = {}) {
         let maxDepthReached = 0;
         let rootRaw = null;
         let rootFiltered = 0;
+        let rootSelfRecursive = false;
         const treeAccount = {
             nodesExpanded: 0,
             confirmedEdges: 0,
+            recursiveEdges: 0,
             unverifiedEdges: 0,
             unverifiedByReason: {},
             excludedTotal: 0,
             excludedByReason: {},
             filteredEdges: 0,
             depthLimitNodes: 0,
+            truncatedChildren: 0,
         };
 
         const buildCallerTree = (funcDef, currentDepth, chainUnverified) => {
@@ -407,6 +419,15 @@ function blast(index, name, options = {}) {
                     treeAccount.filteredEdges += before - callers.length;
                     if (currentDepth === 0) rootFiltered += before - callers.length;
                 }
+                const recursiveCallers = callers.filter(c =>
+                    c.callerFile === funcDef.file &&
+                    c.callerStartLine === funcDef.startLine);
+                if (recursiveCallers.length > 0) {
+                    callers = callers.filter(c => !recursiveCallers.includes(c));
+                    node.selfRecursive = true;
+                    treeAccount.recursiveEdges += recursiveCallers.length;
+                    if (currentDepth === 0) rootSelfRecursive = true;
+                }
                 treeAccount.confirmedEdges += callers.length;
                 if (collect && !chainUnverified) {
                     for (const c of callers) collect.onConfirmed?.(funcDef, c);
@@ -445,6 +466,7 @@ function blast(index, name, options = {}) {
 
                 if (callerEntries.length > maxChildren) {
                     node.truncatedChildren = callerEntries.length - maxChildren;
+                    treeAccount.truncatedChildren += node.truncatedChildren;
                     // Count truncated callers in summary
                     for (const { def: cDef } of callerEntries.slice(maxChildren)) {
                         const tKey = `${cDef.file}:${cDef.startLine}`;
@@ -536,6 +558,7 @@ function blast(index, name, options = {}) {
                 maxDepthReached,
                 unverifiedEdges: treeAccount.unverifiedEdges,
                 ...(expandUnverified && { possiblyAffected: possiblyAffectedSet.size }),
+                ...(rootSelfRecursive && { selfRecursive: true }),
             },
             warnings: warnings.length > 0 ? warnings : undefined
         };
@@ -581,6 +604,7 @@ function reverseTrace(index, name, options = {}) {
         const treeAccount = {
             nodesExpanded: 0,
             confirmedEdges: 0,
+            recursiveEdges: 0,
             unverifiedEdges: 0,
             unverifiedByReason: {},
             excludedTotal: 0,
@@ -600,7 +624,14 @@ function reverseTrace(index, name, options = {}) {
                 unv = unv.filter(c => index.matchesFilters(c.relativePath, { exclude }));
                 if (isExpansion) treeAccount.filteredEdges += before - conf.length - unv.length;
             }
-            return { confirmed: conf, unverified: unv, raw };
+            const recursive = conf.filter(c =>
+                c.callerFile === funcDef.file &&
+                c.callerStartLine === funcDef.startLine);
+            if (recursive.length > 0) {
+                conf = conf.filter(c => !recursive.includes(c));
+                if (isExpansion) treeAccount.recursiveEdges += recursive.length;
+            }
+            return { confirmed: conf, unverified: unv, recursive, raw };
         };
 
         const buildCallerTree = (funcDef, currentDepth, chainUnverified) => {
@@ -629,7 +660,8 @@ function reverseTrace(index, name, options = {}) {
             };
 
             if (currentDepth < maxDepth) {
-                const { confirmed, unverified, raw } = nodeCallers(funcDef, true);
+                const { confirmed, unverified, recursive, raw } = nodeCallers(funcDef, true);
+                if (recursive.length > 0) node.selfRecursive = true;
                 treeAccount.nodesExpanded++;
                 _aggregateExcluded(treeAccount, raw);
                 if (currentDepth === 0) {
@@ -666,7 +698,8 @@ function reverseTrace(index, name, options = {}) {
                         const cKey = `${cDef.file}:${cDef.startLine}`;
                         if (!visited.has(cKey)) {
                             const tiers = nodeCallers(cDef, false);
-                            if (tiers.confirmed.length === 0 && tiers.unverified.length === 0) {
+                            if (tiers.confirmed.length === 0 && tiers.unverified.length === 0 &&
+                                tiers.recursive.length === 0) {
                                 entryPoints.push({ name: cDef.name, file: cDef.relativePath || path.relative(index.root, cDef.file), line: cDef.startLine });
                             }
                         }
@@ -688,9 +721,11 @@ function reverseTrace(index, name, options = {}) {
                 // Entry point only when BOTH tiers are empty; unverified-only
                 // nodes are visibly not-confirmed instead.
                 if (callerEntries.length === 0 && currentDepth > 0) {
-                    if (unverified.length === 0) {
+                    if (unverified.length === 0 && recursive.length === 0) {
                         node.entryPoint = true;
                         entryPoints.push({ name: funcDef.name, file: funcDef.relativePath, line: funcDef.startLine });
+                    } else if (recursive.length > 0) {
+                        node.selfRecursive = true;
                     } else {
                         node.unverifiedCallerCount = unverified.length;
                     }
@@ -699,10 +734,12 @@ function reverseTrace(index, name, options = {}) {
                 // At depth limit: check if this node is an entry point
                 treeAccount.depthLimitNodes++;
                 const tiers = nodeCallers(funcDef, false);
-                if (tiers.confirmed.filter(c => c.callerName).length === 0) {
-                    if (tiers.unverified.length === 0) {
+                if (tiers.confirmed.length === 0) {
+                    if (tiers.unverified.length === 0 && tiers.recursive.length === 0) {
                         node.entryPoint = true;
                         entryPoints.push({ name: funcDef.name, file: funcDef.relativePath, line: funcDef.startLine });
+                    } else if (tiers.recursive.length > 0) {
+                        node.selfRecursive = true;
                     } else {
                         node.unverifiedCallerCount = tiers.unverified.length;
                     }
@@ -716,7 +753,10 @@ function reverseTrace(index, name, options = {}) {
 
         // Also mark root as entry point if it has no callers in either tier
         if (tree && tree.children.length === 0 && maxDepth > 0) {
-            if (rootUnverifiedCount === 0) {
+            const rootConfirmedCount = rootRaw
+                ? rootRaw.filter(c => c.tier !== 'unverified').length
+                : 0;
+            if (rootConfirmedCount === 0 && rootUnverifiedCount === 0 && !tree.selfRecursive) {
                 tree.entryPoint = true;
                 entryPoints.push({ name: def.name, file: def.relativePath, line: def.startLine });
             } else {
@@ -771,6 +811,7 @@ function reverseTrace(index, name, options = {}) {
                 totalFunctions: visited.size - 1, // exclude root
                 maxDepthReached,
                 unverifiedEdges: treeAccount.unverifiedEdges,
+                ...(tree?.selfRecursive && { selfRecursive: true }),
             },
             warnings: warnings.length > 0 ? warnings : undefined
         };
@@ -784,12 +825,12 @@ function reverseTrace(index, name, options = {}) {
  * Two bands (tree contract): `affectedFunctions`/`testFiles` come from the
  * confirmed-chain closure; names reachable only through >= 1 unverified hop
  * land in `possiblyAffected`, their additional test files in
- * `possiblyAffectedTests`. Coverage/uncovered claims are confirmed-band only.
+ * `possiblyAffectedTests`. Static-linkage claims are confirmed-band only.
  *
  * @param {object} index - ProjectIndex instance
  * @param {string} name - Function name
  * @param {object} options - { depth, file, className, exclude, includeMethods }
- * @returns {object|null} Affected test files with coverage stats
+ * @returns {object|null} Affected test files with static-linkage stats
  */
 function affectedTests(index, name, options = {}) {
     index._beginOp();
@@ -898,7 +939,7 @@ function affectedTests(index, name, options = {}) {
                         if (!isTestCaller && fe.callerName) {
                             const defs = index.symbols.get(fe.callerName);
                             const d = defs?.find(x => x.file === fe.callerFile && x.startLine === fe.callerStartLine);
-                            const kindOf = getLanguageModule(cfe.language)?.getEntryPointKind;
+                            const kindOf = getLanguageAdapter(cfe.language)?.getEntryPointKind;
                             if (d && kindOf && kindOf(d) === 'test') isTestCaller = true;
                         }
                         if (!isTestCaller && fe.line != null) {
@@ -1130,7 +1171,7 @@ function affectedTests(index, name, options = {}) {
                 }
 
                 if (fileMatches.size > 0) {
-                    const coveredFunctions = [...fileMatches.keys()];
+                    const linkedFunctions = [...fileMatches.keys()];
                     const allMatches = [];
                     for (const matches of fileMatches.values()) allMatches.push(...matches);
                     // Deduplicate same line+function (test-case line might overlap with call line)
@@ -1144,40 +1185,41 @@ function affectedTests(index, name, options = {}) {
                     }
                     const deduped = [...dedupMap.values()].sort((a, b) => a.line - b.line);
 
-                    // Only count functions with call or test-case matches as covered.
-                    // Import-only or reference-only functions are not real coverage.
-                    const realCoveredAll = coveredFunctions.filter(fn => {
+                    // Only count functions with call or test-case matches as
+                    // statically linked. Import-only or reference-only records
+                    // are useful evidence, but are not an exercising path.
+                    const realLinkedAll = linkedFunctions.filter(fn => {
                         const fnMatches = deduped.filter(m => m.functionName === fn);
                         return fnMatches.some(m => m.matchType === 'call' || m.matchType === 'test-case');
                     });
-                    const realCoveredFunctions = realCoveredAll.filter(fn => affectedNames.has(fn));
-                    const possiblyCovered = realCoveredAll.filter(fn => possiblyNames.has(fn));
+                    const staticallyLinkedFunctions = realLinkedAll.filter(fn => affectedNames.has(fn));
+                    const possiblyLinkedFunctions = realLinkedAll.filter(fn => possiblyNames.has(fn));
 
-                    if (realCoveredFunctions.length > 0) {
-                        // Confirmed band: matches for confirmed-covered names
+                    if (staticallyLinkedFunctions.length > 0) {
+                        // Confirmed band: matches for confirmed-linked names
                         const realMatches = deduped.filter(m =>
                             affectedNames.has(m.functionName) &&
                             (m.matchType === 'call' || m.matchType === 'test-case' ||
-                             realCoveredFunctions.includes(m.functionName))
+                             staticallyLinkedFunctions.includes(m.functionName))
                         );
                         results.push({
                             file: fileEntry.relativePath,
-                            coveredFunctions: realCoveredFunctions,
-                            ...(possiblyCovered.length > 0 && { possiblyCovered }),
+                            linkedFunctions: staticallyLinkedFunctions,
+                            ...(possiblyLinkedFunctions.length > 0 && { possiblyLinkedFunctions }),
                             matchCount: realMatches.length,
                             matches: realMatches
                         });
-                    } else if (possiblyCovered.length > 0) {
+                    } else if (possiblyLinkedFunctions.length > 0) {
                         // Possible band: file reaches the change only through
                         // unverified chains.
                         const possibleMatches = deduped.filter(m =>
                             possiblyNames.has(m.functionName) &&
                             (m.matchType === 'call' || m.matchType === 'test-case' ||
-                             possiblyCovered.includes(m.functionName))
+                             possiblyLinkedFunctions.includes(m.functionName))
                         );
                         possibleResults.push({
                             file: fileEntry.relativePath,
-                            coveredFunctions: possiblyCovered,
+                            linkedFunctions: possiblyLinkedFunctions,
                             matchCount: possibleMatches.length,
                             matches: possibleMatches
                         });
@@ -1199,22 +1241,25 @@ function affectedTests(index, name, options = {}) {
             if (inResults || inPossible) {
                 const existing = inResults || inPossible;
                 const have = new Set([
-                    ...existing.coveredFunctions,
-                    ...(existing.possiblyCovered || []),
+                    ...existing.linkedFunctions,
+                    ...(existing.possiblyLinkedFunctions || []),
                 ]);
                 const extra = [...entry.byName.keys()].filter(n => !have.has(n)).sort(codeUnitCompare);
                 if (extra.length > 0) {
                     if (inResults) {
-                        existing.possiblyCovered = [...(existing.possiblyCovered || []), ...extra].sort(codeUnitCompare);
+                        existing.possiblyLinkedFunctions = [
+                            ...(existing.possiblyLinkedFunctions || []),
+                            ...extra,
+                        ].sort(codeUnitCompare);
                     } else {
-                        existing.coveredFunctions = [...existing.coveredFunctions, ...extra].sort(codeUnitCompare);
+                        existing.linkedFunctions = [...existing.linkedFunctions, ...extra].sort(codeUnitCompare);
                     }
                 }
                 continue;
             }
-            const covered = [...entry.byName.keys()].sort(codeUnitCompare);
+            const linked = [...entry.byName.keys()].sort(codeUnitCompare);
             const matches = [];
-            for (const fn of covered) {
+            for (const fn of linked) {
                 for (const ln of [...entry.byName.get(fn)].sort((a, b) => a - b)) {
                     matches.push({
                         line: ln,
@@ -1226,17 +1271,17 @@ function affectedTests(index, name, options = {}) {
             }
             possibleResults.push({
                 file: entry.rel,
-                coveredFunctions: covered,
+                linkedFunctions: linked,
                 matchCount: matches.length,
                 matches,
             });
         }
 
-        // Sort by coverage breadth then alphabetically
-        results.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || codeUnitCompare(a.file, b.file));
-        possibleResults.sort((a, b) => b.coveredFunctions.length - a.coveredFunctions.length || codeUnitCompare(a.file, b.file));
+        // Sort by linkage breadth then alphabetically
+        results.sort((a, b) => b.linkedFunctions.length - a.linkedFunctions.length || codeUnitCompare(a.file, b.file));
+        possibleResults.sort((a, b) => b.linkedFunctions.length - a.linkedFunctions.length || codeUnitCompare(a.file, b.file));
 
-        // Compute coverage stats.
+        // Compute static-linkage stats.
         // Filter out test function names from affectedNames — they are callers,
         // not production symbols that need test coverage.
         const isProductionName = (n) => {
@@ -1246,7 +1291,7 @@ function affectedTests(index, name, options = {}) {
             // language's getEntryPointKind says so; they need no coverage.
             for (const [, fe] of index.files) {
                 if (isTestFile(fe.relativePath, fe.language)) continue;
-                const langModule = getLanguageModule(fe.language);
+                const langModule = getLanguageAdapter(fe.language);
                 const kindOf = langModule?.getEntryPointKind;
                 if (fe.symbols?.some(s => s.name === n && (!kindOf || kindOf(s) !== 'test'))) {
                     return true;
@@ -1262,15 +1307,20 @@ function affectedTests(index, name, options = {}) {
         const namesForCoverage = productionNames.size > 0 ? productionNames : affectedNames;
         const possiblyProduction = [...possiblyNames].filter(isProductionName);
 
-        const coveredSet = new Set();
-        for (const r of results) for (const f of r.coveredFunctions) {
-            if (namesForCoverage.has(f)) coveredSet.add(f);
+        const linkedSet = new Set();
+        for (const r of results) for (const f of r.linkedFunctions) {
+            if (namesForCoverage.has(f)) linkedSet.add(f);
         }
-        const uncovered = [...namesForCoverage].filter(n => !coveredSet.has(n));
+        const notStaticallyLinked = [...namesForCoverage].filter(n => !linkedSet.has(n));
 
         return {
             root: blastResult.root, file: blastResult.file, line: blastResult.line,
             depth: blastResult.maxDepth,
+            selection: {
+                basis: 'static-call-and-reference-links',
+                runtimeCoverage: false,
+                absenceProvesUntested: false,
+            },
             affectedFunctions: [...namesForCoverage],
             possiblyAffected: possiblyProduction,
             testFiles: results,
@@ -1280,13 +1330,13 @@ function affectedTests(index, name, options = {}) {
             summary: {
                 totalAffected: namesForCoverage.size,
                 totalTestFiles: results.length,
-                coveredFunctions: coveredSet.size,
-                uncoveredCount: uncovered.length,
+                staticallyLinkedFunctions: linkedSet.size,
+                notStaticallyLinkedCount: notStaticallyLinked.length,
                 possiblyAffected: possiblyProduction.length,
                 possiblyAffectedTests: possibleResults.length,
                 unverifiedEdges: blastResult.summary ? blastResult.summary.unverifiedEdges : 0,
             },
-            uncovered,
+            notStaticallyLinked,
             warnings: blastResult.warnings,
         };
     } finally { index._endOp(); }
@@ -1329,7 +1379,7 @@ function _addAffectedTestCases(index, filePath, fileEntry, funcName, fileMatches
     } else {
         if (!fileEntry.symbols) return;
         try {
-            const langModule = getLanguageModule(lang);
+            const langModule = getLanguageAdapter(lang);
             if (!langModule) return;
             // Prefer the kinded predicate so we don't mis-tag fn main() / fn init()
             // (runtime entries) as test cases (BUG-CX). Fall back to isEntryPoint