ucn 5.5.3 → 5.6.1

package/core/search.js

@@ -17,6 +17,8 @@ const { isAccessorDefinition, findAccessorReferences } = require('./accessors');
 const isSafeRegex = require('safe-regex2');
 const { RE2JS } = require('re2js');
 const { UcnError } = require('./errors');
+const { paramValues } = require('./registry');
+const { createTestModel, addTestCaseRows, linkFiles, testSite, testSiteKey } = require('./test-units');
 
 // Keep the established search-input contract for the canonical catastrophic
 // nested-single-atom family even though the RE2-compatible engine could run it
@@ -36,11 +38,8 @@ function buildGlobMatcher(pattern, caseSensitive) {
     return (name) => regex.test(name);
 }
 
-const STRUCTURAL_TYPES = new Set([
-    'function', 'class', 'call', 'method', 'type', 'constructor',
-    'state', 'field', 'constant', 'macro', 'variable',
-    'interface', 'enum', 'struct', 'trait', 'record', 'namespace',
-]);
+// The kinds a structural search takes: the parameter table's set.
+const STRUCTURAL_TYPES = new Set(paramValues('type', 'search'));
 
 /**
  * Substring match. Case-insensitive by default.
@@ -209,14 +208,18 @@ function _applyFindFilters(index, matches, options) {
 
     // Rank cheaply before adjudicating callers. A broad inventory must never
     // pay for pinned caller resolution on rows the caller will not receive.
+    const definitionOrder = (a, b) =>
+        (b._fuzzyScore || 0) - (a._fuzzyScore || 0) ||
+        Number(isTestFile(a.relativePath || '', a.language)) -
+            Number(isTestFile(b.relativePath || '', b.language)) ||
+        codeUnitCompare(a.relativePath || '', b.relativePath || '') ||
+        a.startLine - b.startLine || codeUnitCompare(a.name, b.name);
     const ranked = filtered.map(symbol => ({
         symbol, counts: index.countSymbolUsages(symbol),
     }));
     if (options.limit > 0 && ranked.length > options.limit) {
         ranked.sort((a, b) => b.counts.total - a.counts.total ||
-            codeUnitCompare(a.symbol.relativePath || '', b.symbol.relativePath || '') ||
-            a.symbol.startLine - b.symbol.startLine ||
-            codeUnitCompare(a.symbol.name, b.symbol.name));
+            definitionOrder(a.symbol, b.symbol));
     }
     const survivors = options.limit > 0 ? ranked.slice(0, options.limit) : ranked;
     const withCounts = survivors.map(({ symbol: m, counts }) => {
@@ -258,7 +261,7 @@ function _applyFindFilters(index, matches, options) {
     });
 
     // Sort by usage count (most-used first)
-    withCounts.sort((a, b) => b.usageCount - a.usageCount);
+    withCounts.sort((a, b) => b.usageCount - a.usageCount || definitionOrder(a, b));
 
     return withCounts;
 }
@@ -1313,6 +1316,10 @@ function tests(index, nameOrFile, options = {}) {
     index._beginOp();
     try {
     const results = [];
+    const model = createTestModel(index);
+    // Files where a title that names the term is a link (the term on a test
+    // line is the project's symbol, not the file's own helper).
+    const titled = new Set();
 
     // Check if it's a file path
     const isFilePath = nameOrFile.includes('/') || nameOrFile.includes('\\') ||
@@ -1325,7 +1332,7 @@ function tests(index, nameOrFile, options = {}) {
     let sourceFileFilter = null;
     let targetDefs = [];
     if (options.file && !isFilePath) {
-        targetDefs = index.find(nameOrFile, { exact: true, file: options.file, className: options.className });
+        targetDefs = index.find(nameOrFile, { exact: true, file: options.file, className: options.className, skipCounts: true });
         if (targetDefs.length > 0) {
             sourceFileFilter = _buildSourceFileImporters(index, targetDefs);
         }
@@ -1333,12 +1340,11 @@ function tests(index, nameOrFile, options = {}) {
         // The execute handler validates before calling, so this path means
         // the file matched but no exact symbol — fall through gracefully.
     } else if (!isFilePath) {
-        targetDefs = index.find(nameOrFile, { exact: true, className: options.className });
+        targetDefs = index.find(nameOrFile, { exact: true, className: options.className, skipCounts: true });
     }
     // A pinned definition among same-name ones (an overload, a constructor
     // beside its class and siblings, fix #430): calls are this definition's
     // only when the caller engine attributes them to it.
-    const pinnedFamily = !isFilePath && options.definition && targetDefs.length > 1;
     if (!isFilePath && options.definition) targetDefs = [options.definition];
 
     // Find all test files
@@ -1358,9 +1364,50 @@ function tests(index, nameOrFile, options = {}) {
         }
     }
 
+    // A file's name does not decide what a test executes: the body of a
+    // test a class inherits stands where its base class is, and a runner
+    // takes tests from files of any name. A call site the caller engine
+    // finds in such a file is a test's where the test model says a test
+    // executes that line (core/test-units.js): the file joins the test
+    // files, test code within those lines.
+    const testInfoByPath = new Map(testFiles.map(info => [info.path, info]));
+    const testInfoOf = filePath => {
+        if (testInfoByPath.has(filePath)) return testInfoByPath.get(filePath);
+        const entry = index.files.get(filePath);
+        const ranges = entry ? model.testRangesOf(filePath) : [];
+        const info = ranges.length > 0 ? { path: filePath, entry, testRanges: ranges } : null;
+        testInfoByPath.set(filePath, info);
+        if (info) testFiles.push(info);
+        return info;
+    };
+
     const searchTerm = isFilePath
         ? path.basename(nameOrFile, path.extname(nameOrFile))
         : nameOrFile;
+    const callerSites = [];
+    const excludedCallableLines = new Map();
+    const globallyUniqueTarget = !isFilePath && targetDefs.length === 1;
+    if (!isFilePath) for (const def of targetDefs) {
+        const raw = index.findCallers(searchTerm, {
+            targetDefinitions: [def], collectAccount: true, unverifiedEnrichLimit: Infinity,
+        });
+        callerSites.push(
+            ...raw.map(site => ({ ...site, _testEvidenceTier: 'confirmed' })),
+            ...(globallyUniqueTarget ? (raw.unverifiedEntries || []).map(site => ({
+                ...site, _testEvidenceTier: 'unverified',
+            })) : []),
+        );
+        const counted = new Set();
+        for (const site of raw.accountRaw?.excludedEntries || []) {
+            const key = `${site.file}:${site.line}`;
+            if (counted.has(key)) continue;
+            counted.add(key);
+            let lines = excludedCallableLines.get(site.file);
+            if (!lines) { lines = new Map(); excludedCallableLines.set(site.file, lines); }
+            lines.set(site.line, (lines.get(site.line) || 0) + 1);
+        }
+    }
+    const acceptedCallableLines = new Set(callerSites.map(site => `${site.file}:${site.line}`));
 
     // File-path target: module specifiers are string literals, so the
     // basename usage scan is blind to import-linked tests in JS/TS
@@ -1388,7 +1435,6 @@ function tests(index, nameOrFile, options = {}) {
     // module-level coverage remain visible.
     const fileTargetCallerSites = new Map(); // absolute test file → tiered sites
     if (isFilePath && targetRels) {
-        const testFileInfo = new Map(testFiles.map(info => [info.path, info]));
         const fileTargetDefs = [];
         for (const [, fe] of index.files) {
             if (!targetRels.has(fe.relativePath)) continue;
@@ -1401,7 +1447,7 @@ function tests(index, nameOrFile, options = {}) {
                 targetDefinitions: [def],
                 collectAccount: true,
             });
-            const globallyUnique = index.find(def.name, { exact: true }).length === 1;
+            const globallyUnique = index.symbols.get(def.name)?.length === 1;
             const sites = [
                 ...raw.map(site => ({ ...site, _testEvidenceTier: 'confirmed' })),
                 ...(globallyUnique ? (raw.unverifiedEntries || []).map(site => ({
@@ -1410,7 +1456,7 @@ function tests(index, nameOrFile, options = {}) {
                 })) : []),
             ];
             for (const site of sites) {
-                const info = testFileInfo.get(site.file);
+                const info = testInfoOf(site.file);
                 if (!info) continue;
                 if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
                 let rows = fileTargetCallerSites.get(site.file);
@@ -1539,7 +1585,18 @@ function tests(index, nameOrFile, options = {}) {
                 // own definition (fix #246).
                 if (localShadow && !usage.receiver && usage.usageType !== 'import') continue;
 
-                if (pinnedFamily && usage.usageType === 'call') continue;
+                // File eligibility only discovers candidates. A call's
+                // spelling does not establish which declaration it reaches;
+                // exact-target caller evidence below owns every call row.
+                if (targetDefs.length > 0 && usage.usageType === 'call') continue;
+                const classBodyProof = !usage.receiver && usage.usageType === 'reference' &&
+                    classBodyReferenceTargets(index, testPath, entry.language, usage, targetDefs);
+                // Method/function values are caller candidates too. A file
+                // importing any sibling cannot resurrect a reference the
+                // engine attributed to another declaration.
+                if (usage.usageType !== 'import' &&
+                    excludedCallableLines.get(testPath)?.get(usage.line) === targetDefs.length &&
+                    !acceptedCallableLines.has(`${testPath}:${usage.line}`) && !classBodyProof) continue;
                 // A line is claimed only by a usage that is recorded: two
                 // same-kind tokens on one line (`a.m = b.m`) are judged
                 // separately, so a rejected first token never hides a
@@ -1625,6 +1682,7 @@ function tests(index, nameOrFile, options = {}) {
                         const nmUsages = index._getCachedUsages(testPath, nm) || [];
                         for (const u of nmUsages) {
                             if (u.usageType === 'definition' || u.usageType === 'import') continue;
+                            if (u.usageType === 'call') continue; // exact file-target evidence below
                             if (testRanges && !lineInRanges(u.line, testRanges)) continue;
                             const lineKey = `${u.line}:${u.usageType}:${nm}`;
                             if (seenLines.has(lineKey)) continue;
@@ -1648,9 +1706,9 @@ function tests(index, nameOrFile, options = {}) {
                 const matchType = site._testEvidenceTier === 'confirmed'
                     ? 'call'
                     : 'unverified-call';
-                if (matches.some(m => m.line === site.line && m.matchType === matchType)) continue;
+                if (matches.some(m => testSiteKey(m) === testSiteKey(site) && m.matchType === matchType)) continue;
                 matches.push({
-                    line: site.line,
+                    ...testSite(site),
                     content: (site.content || index.getLineContent(testPath, site.line) || '').trim(),
                     matchType,
                     evidenceTier: site._testEvidenceTier,
@@ -1659,12 +1717,11 @@ function tests(index, nameOrFile, options = {}) {
                 });
             }
 
-            // Language-aware test-case detection. Under a local same-name
-            // shadow the term on a test line is the file's OWN helper —
-            // only anchor test cases to matches that survived the shadow.
+            // Under a local same-name shadow the term in a test's title is
+            // the file's OWN helper: titles link only where a match survived.
             if (!isFilePath && sourceFileLinked &&
                 (!localShadow || matches.some(m => m.matchType !== 'import'))) {
-                _addTestCaseMatches(index, testPath, entry, searchTerm, className, instanceTypeMap, matches);
+                titled.add(entry.relativePath);
             }
 
             // Deduplicate: if a line already has a 'call' or 'import', don't also add 'test-case'
@@ -1694,38 +1751,20 @@ function tests(index, nameOrFile, options = {}) {
         }
     }
 
-    // Compiler-shaped caller supplement (trust command arm): the literal
-    // usage scan above is excellent for imports/type/string references, but
-    // receiver aliases and re-exported module calls are owned by the caller
-    // engine. Merge its CONFIRMED exact-target test sites so `tests` cannot
-    // miss calls that `about`/`impact` already know about. For a globally
+    // Callable test links use the caller engine's exact-target decisions,
+    // including aliases and function values that do not spell the target's
+    // name. The literal scan contributes imports/type/string references,
+    // never an independent call identity. For a globally
     // unique callable name, also retain account-unverified sites under the
     // explicit `unverified-call` label: independent compiler/LSP evaluation
     // shows these contain real interface/trait dispatch that a test-discovery
     // command must not silently drop. Repeated names never receive that broad
     // supplement because it would leak sibling classes/files.
     if (!isFilePath && targetDefs.length > 0) {
-        const testInfo = new Map(testFiles.map(t => [t.path, t]));
-        const callerSites = [];
         // A pinned definition's unverified sites were adjudicated against it
         // alone, like a globally unique name's (fix #430).
-        const globallyUniqueTarget = !!options.definition || index.find(searchTerm, { exact: true }).length === 1;
-        for (const def of targetDefs) {
-            const raw = index.findCallers(searchTerm, {
-                targetDefinitions: [def],
-                collectAccount: true,
-            });
-            callerSites.push(
-                ...raw.map(c => ({ ...c, _testEvidenceTier: 'confirmed' })),
-                ...(globallyUniqueTarget ? (raw.unverifiedEntries || []).map(c => ({
-                    ...c,
-                    _testEvidenceTier: 'unverified',
-                })) : []),
-            );
-        }
-
         for (const site of callerSites) {
-            const info = testInfo.get(site.file);
+            const info = testInfoOf(site.file);
             if (!info) continue;
             if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
             // Every site here was adjudicated against the exact target
@@ -1754,12 +1793,12 @@ function tests(index, nameOrFile, options = {}) {
                 fileResult = { file: info.entry.relativePath, matches: [] };
                 results.push(fileResult);
             }
-            if (fileResult.matches.some(m => m.line === site.line &&
+            if (fileResult.matches.some(m => testSiteKey(m) === testSiteKey(site) &&
                 ['call', 'unverified-call'].includes(m.matchType))) continue;
             fileResult.matches = fileResult.matches.filter(m =>
                 !(m.line === site.line && m.matchType === 'test-case'));
             fileResult.matches.push({
-                line: site.line,
+                ...testSite(site),
                 content: (site.content || index.getLineContent(site.file, site.line) || '').trim(),
                 matchType: site._testEvidenceTier === 'confirmed' ? 'call' : 'unverified-call',
                 evidenceTier: site._testEvidenceTier,
@@ -1780,16 +1819,22 @@ function tests(index, nameOrFile, options = {}) {
         const nestedTypeDefs = targetDefs.filter(def => def.enclosingType &&
             ['class', 'struct', 'interface', 'type', 'enum', 'trait', 'record', 'union'].includes(def.type));
         if (accessorDefs.length > 0 || nestedTypeDefs.length > 0) {
-            const testPaths = new Set(testFiles.map(t => t.path));
+            // Reference-only tests have no call site to add their file to
+            // testFiles above. Let the reference engines find their sites
+            // first, then ask the same model which lines a test executes.
+            // The index-only gate spares files that cannot hold test code;
+            // filenames alone never remove a candidate.
+            const referencePaths = new Set([...index.files.keys()].filter(filePath =>
+                testInfoByPath.get(filePath) || model.mayHoldTests(filePath)));
             const globallyUnique = index.find(searchTerm, { exact: true }).length === 1;
             for (const def of [...accessorDefs, ...nestedTypeDefs]) {
                 const types = nestedTypeDefs.includes(def)
-                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: testPaths }) : null;
+                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: referencePaths }) : null;
                 const typeSite = site => ({ ...site, absoluteFile: path.join(index.root, site.file) });
                 const refs = types ? {
                     confirmed: types.byFile.flatMap(group => group.sites).map(typeSite),
                     unverified: types.unverifiedSites.map(typeSite),
-                } : findAccessorReferences(index, searchTerm, def, { files: testPaths });
+                } : findAccessorReferences(index, searchTerm, def, { files: referencePaths });
                 if (!refs) continue;
                 const rows = [
                     ...refs.confirmed.map(r => ({ ...r, tierName: 'confirmed' })),
@@ -1797,7 +1842,7 @@ function tests(index, nameOrFile, options = {}) {
                         ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
                 ];
                 for (const ref of rows) {
-                    const info = testInfo.get(ref.absoluteFile);
+                    const info = testInfoOf(ref.absoluteFile);
                     if (!info) continue;
                     if (info.testRanges && !lineInRanges(ref.line, info.testRanges)) continue;
                     if (excludeArr.length > 0 &&
@@ -1835,6 +1880,55 @@ function tests(index, nameOrFile, options = {}) {
         results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
     }
 
+    // The tests that hold the matches (core/test-units.js): one row per
+    // test, then what the file is to its runner and how to run it.
+    const absolute = new Map(testFiles.map(info => [info.entry.relativePath, info.path]));
+    const linesByFile = new Map();
+    for (const fileResult of results) {
+        const testPath = absolute.get(fileResult.file);
+        if (!testPath) continue;
+        addTestCaseRows(model, index, testPath, isFilePath ? null : searchTerm, fileResult.matches, {
+            counts: match => match.matchType !== 'import',
+            titles: titled.has(fileResult.file),
+            titleNeedsMatch: !!className,
+        });
+        linesByFile.set(testPath,
+            fileResult.matches.filter(match => match.matchType !== 'import'));
+    }
+    // A test a class inherits runs where the class is: the file of a class
+    // that inherits a linked test is a result of its own, with the test.
+    const byFile = new Map(results.map(fileResult => [fileResult.file, fileResult]));
+    for (const [testPath, linked] of linkFiles(model, index, linesByFile)) {
+        const relativePath = index.files.get(testPath).relativePath;
+        let fileResult = byFile.get(relativePath);
+        if (!fileResult) {
+            fileResult = { file: relativePath, matches: [] };
+            byFile.set(relativePath, fileResult);
+            results.push(fileResult);
+        }
+        for (const unit of linked.units) {
+            if (!unit.inheritedFrom) continue;
+            fileResult.matches.push({
+                line: unit.line,
+                content: (index.getLineContent(testPath, unit.line) || '').trim(),
+                matchType: 'inherited-test',
+                name: unit.name,
+                from: unit.inheritedFrom,
+            });
+        }
+        fileResult.matches.sort((a, b) => (a.line || 0) - (b.line || 0) ||
+            codeUnitCompare(a.matchType || '', b.matchType || '') || codeUnitCompare(a.name || '', b.name || ''));
+        fileResult.role = linked.role;
+        if (linked.runner) fileResult.runner = linked.runner;
+        fileResult.tests = linked.tests;
+        if (linked.moreTests) fileResult.moreTests = true;
+        if (linked.conditionalTests) fileResult.conditionalTests = linked.conditionalTests;
+        if (linked.units.length > 0) fileResult.units = linked.units;
+        if (linked.run) fileResult.run = linked.run;
+        else if (linked.runWithheld) fileResult.runWithheld = linked.runWithheld;
+    }
+    results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
+
     return results;
     } finally { index._endOp(); }
 }
@@ -2181,117 +2275,6 @@ function _receiverMatchesClass(usage, dispatchNames, instanceTypeMap, lineConten
     return false;
 }
 
-/**
- * Language-aware test-case detection.
- *
- * JS/TS: describe, it, test, spec calls with searchTerm in the description.
- * Go: TestXxx, BenchmarkXxx, ExampleXxx functions containing a usage of searchTerm.
- * Python: test_ functions or TestCase methods containing a usage of searchTerm.
- * Java: @Test-annotated methods containing a usage of searchTerm.
- * Rust: #[test]-attributed functions containing a usage of searchTerm.
- */
-function _addTestCaseMatches(index, filePath, fileEntry, searchTerm, className, instanceTypeMap, matches) {
-    const matchLines = new Set(matches.map(m => m.line));
-    const lang = fileEntry.language;
-
-    if (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') {
-        // JS/TS: find describe/it/test/spec calls from getCachedCalls
-        const calls = getCachedCalls(index, filePath);
-        if (!calls) return;
-        const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
-        // Word-boundary match: `describe("untargeted zone")` is not a test
-        // case for `target` (fix #246 — raw substring matched mid-word).
-        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(searchTerm) + '([^\\w$]|$)');
-        for (const call of calls) {
-            if (!testFrameworkCalls.has(call.name)) continue;
-            const lineContent = index.getLineContent(filePath, call.line);
-            // Check if searchTerm appears in the description string on this line
-            if (termPattern.test(lineContent) && !matchLines.has(call.line)) {
-                // className scoping: only add test-case if the test body has a
-                // class-scoped match (call or class-receiver reference) — not just
-                // any mention of className.
-                if (className) {
-                    const endLine = _estimateTestBlockEnd(index, filePath, call.line);
-                    const hasClassScopedMatch = matches.some(m =>
-                        m.line >= call.line && m.line <= endLine &&
-                        m.matchType !== 'import'
-                    );
-                    if (!hasClassScopedMatch) continue;
-                }
-                matches.push({
-                    line: call.line,
-                    content: lineContent.trim(),
-                    matchType: 'test-case'
-                });
-                matchLines.add(call.line);
-            }
-        }
-    } else {
-        // Go/Python/Java/Rust: check if any AST usage falls within a test function's range
-        if (!fileEntry.symbols) return;
-        try {
-            const langModule = getLanguageAdapter(lang);
-            if (!langModule) return;
-            // Prefer kinded predicate so fn main() and fn init() aren't classified
-            // as test cases (BUG-CX). Fall back to isEntryPoint for compat.
-            const classify = langModule.getEntryPointKind
-                ? (s) => langModule.getEntryPointKind(s) === 'test'
-                : langModule.isEntryPoint;
-            if (!classify) return;
-
-            // Find test symbols
-            for (const symbol of fileEntry.symbols) {
-                if (!classify(symbol)) continue;
-                // Check if any non-import usage of searchTerm falls within this test function
-                const usageInRange = matches.some(m =>
-                    m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                    m.matchType !== 'import'
-                );
-                if (usageInRange && !matchLines.has(symbol.startLine)) {
-                    // className scoping: verify the test body has class-scoped matches
-                    if (className) {
-                        const hasClassScopedMatch = matches.some(m =>
-                            m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                            m.matchType !== 'import'
-                        );
-                        if (!hasClassScopedMatch) continue;
-                    }
-                    const lineContent = index.getLineContent(filePath, symbol.startLine);
-                    matches.push({
-                        line: symbol.startLine,
-                        content: lineContent.trim(),
-                        matchType: 'test-case'
-                    });
-                    matchLines.add(symbol.startLine);
-                }
-            }
-        } catch (e) {
-            // Skip if language module unavailable
-        }
-    }
-}
-
-/**
- * Estimate the end line of a test block (it/test/describe callback) by tracking
- * brace nesting from the start line.
- */
-function _estimateTestBlockEnd(index, filePath, startLine) {
-    const content = index._readFile(filePath);
-    if (!content) return startLine + 5;
-    const lines = content.split('\n');
-    let depth = 0;
-    let started = false;
-    for (let i = startLine - 1; i < lines.length; i++) {
-        const line = lines[i];
-        for (const ch of line) {
-            if (ch === '{' || ch === '(') { depth++; started = true; }
-            else if (ch === '}' || ch === ')') { depth--; }
-        }
-        if (started && depth <= 0) return i + 1; // 1-based
-    }
-    return Math.min(startLine + 10, lines.length);
-}
-
 /**
  * Deduplicate matches: prefer more specific matchTypes on the same line.
  * Priority: test-case > call > import > string-ref > reference
@@ -2300,9 +2283,10 @@ function _deduplicateMatches(matches) {
     const byLine = new Map();
     const priority = { 'test-case': 5, 'call': 4, 'import': 3, 'string-ref': 2, 'reference': 1 };
     for (const m of matches) {
-        const existing = byLine.get(m.line);
+        const key = testSiteKey(m);
+        const existing = byLine.get(key);
         if (!existing || (priority[m.matchType] || 0) > (priority[existing.matchType] || 0)) {
-            byLine.set(m.line, m);
+            byLine.set(key, m);
         }
     }
     return [...byLine.values()].sort((a, b) => a.line - b.line);

package/core/shared.js

@@ -260,49 +260,6 @@ function isOverrideMarked(def) {
     return false;
 }
 
-// Per-language text patterns for the "blind spots" UCN's AST can't follow:
-// eval/exec-style code execution and reflection (dynamic attribute access /
-// dynamic dispatch). ONE source of truth so doctor's trust scan and
-// detectCompleteness's about-footer warning count identically (field-report #2:
-// they used to diverge — doctor 497 reflection vs footer 194, eval 3 vs 2 —
-// because each kept its own regex set). Dynamic imports are NOT here: those are
-// structural (fileEntry.dynamicImports), the AST-accurate count both paths share.
-// `new Function(...)` is categorized as eval (code execution), not reflection.
-const BLINDSPOT_TEXT_PATTERNS = {
-    reflection: {
-        python:     /\b(getattr|hasattr|setattr|__import__|importlib\.import_module)\s*\(/g,
-        javascript: /\bReflect\.\w+\s*\(/g,
-        typescript: /\bReflect\.\w+\s*\(/g,
-        go:         /\breflect\.\w+\s*\(/g,
-        java:       /\.getDeclaredMethod\b|\.getMethod\b|\.getDeclaredField\b|Class\.forName\b/g,
-        rust:       /\bAny::downcast/g,
-    },
-    eval: {
-        python:     /\b(eval|exec)\s*\(/g,
-        javascript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-        typescript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-    },
-};
-
-/** True when a language has any text-blind-spot pattern (so callers can skip the file read otherwise). */
-function hasTextBlindspots(language) {
-    return !!(BLINDSPOT_TEXT_PATTERNS.reflection[language] || BLINDSPOT_TEXT_PATTERNS.eval[language]);
-}
-
-/**
- * Count text-detected blind spots (eval/exec, reflection) in one file's source.
- * Returns { eval, reflection } OCCURRENCE counts (global match). Shared by doctor
- * and detectCompleteness so both report the same numbers (field-report #2).
- */
-function countTextBlindspots(content, language) {
-    const reRe = BLINDSPOT_TEXT_PATTERNS.reflection[language];
-    const evRe = BLINDSPOT_TEXT_PATTERNS.eval[language];
-    return {
-        eval: evRe ? (content.match(evRe) || []).length : 0,
-        reflection: reRe ? (content.match(reRe) || []).length : 0,
-    };
-}
-
 /**
  * Line ranges of INLINE test symbols in a source file — Rust #[test] fns and
  * #[cfg(test)] module members. A production file promoted to "test file"
@@ -614,8 +571,6 @@ module.exports = { literalNameRegex,
     looksLikeHandle,
     isTestPath,
     isOverrideMarked,
-    hasTextBlindspots,
-    countTextBlindspots,
     isPathInsideRoot,
     isMacroNamespaceDefinition,
 };