ucn 5.5.3 → 5.6.0

package/core/analysis.js

@@ -11,9 +11,10 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const { UcnError } = require('./errors');
+const { paramFact } = require('./registry');
 const { parse } = require('./parser');
 const { detectLanguage, langTraits } = require('../languages');
-const { NON_CALLABLE_TYPES, addTestExclusions, countTextBlindspots,
+const { NON_CALLABLE_TYPES, addTestExclusions,
     codeUnitCompare, formatSymbolHandle, isValueDefinition } = require('./shared');
 const { isTestFile } = require('./discovery');
 // Entry-point detection loads on first use (fix #375).
@@ -24,12 +25,12 @@ const symbolKey = (file, line) => entrypoints().symbolKey(file, line);
 const { getLanguageAdapter } = require('../languages');
 const { parseOpenCallShape } = require('../languages/rust-value-flow');
 const { projectComputedDispatch, declarationSnapshots } = require('./ast-analysis');
+const { callableContract, classifyChange, baseCounterpart, parseRevision, moduleChange, declaresPlainReturn } = require('./change-kinds');
 const { findAccessorReferences } = require('./accessors');
 
 // JS/TS test framework helpers — calls to these bracket a test case.
 // Used to flag call sites whose enclosing function is an arrow callback
 // passed to one of these (the common pattern in mocha/jest/vitest).
-const _JS_TEST_FRAMEWORK_CALLS = new Set(['describe', 'it', 'test', 'spec', 'context', 'suite']);
 
 /**
  * Give agents the exact indexed definitions behind a same-name ambiguity.
@@ -88,66 +89,31 @@ function buildAmbiguityCandidates(index, name, selected, unverified) {
 }
 
 /**
- * Tag each call site with `inTestCase` based on its enclosing function's
- * entry-point classification. Uses each language's `getEntryPointKind`
- * predicate (kind === 'test') so results match `affectedTests`/etc.
- *
- * For JS/TS/HTML, function-level entry-point classification only covers
- * framework lifecycle methods. Test bodies are framework callbacks
- * (`it('name', () => {...})`), so we additionally tag a site as inTestCase
- * when its file has a `describe`/`it`/`test` framework call that brackets
- * the enclosing function — mirroring `_addAffectedTestCases` in tracing.js.
+ * Tag each call site with `inTestCase`: its enclosing function is one the
+ * language's harness invokes (`getEntryPointKind` says 'test'), or its line
+ * sits in a test or suite the file declares (core/test-units.js, the one
+ * model of what a test is).
  *
  * Mutates each site in place (sets `site.inTestCase = boolean`).
  */
 function tagInTestCase(index, sites) {
     if (!Array.isArray(sites) || sites.length === 0) return;
-    // Per-file cache: language module + JS framework call ranges.
-    const fileMeta = new Map();
-    function getFileMeta(filePath) {
-        if (!filePath) return null;
-        if (fileMeta.has(filePath)) return fileMeta.get(filePath);
-        const fe = index.files.get(filePath);
-        if (!fe) { fileMeta.set(filePath, null); return null; }
-        let langModule = null;
-        try { langModule = getLanguageAdapter(fe.language); } catch (_) { /* ignore */ }
-        const meta = { fileEntry: fe, langModule, language: fe.language, jsTestRanges: null };
-        // For JS-family files, build line ranges of describe/it/test framework calls.
-        if (langModule && isTestFile(fe.relativePath, fe.language) &&
-            (fe.language === 'javascript' || fe.language === 'typescript' ||
-            fe.language === 'tsx' || fe.language === 'html')) {
-            try {
-                const calls = index.getCachedCalls ? index.getCachedCalls(filePath) : null;
-                if (Array.isArray(calls)) {
-                    const ranges = [];
-                    for (const call of calls) {
-                        if (!_JS_TEST_FRAMEWORK_CALLS.has(call.name)) continue;
-                        // Get the enclosing test-block end via existing fn-bound estimate.
-                        // Without a proper bracket scan we use the next-fn-boundary or +200 lines.
-                        let endLine = call.line + 200;
-                        // Try using the enclosing-symbol range as an upper bound when possible.
-                        if (fe.symbols) {
-                            for (const sym of fe.symbols) {
-                                if (sym.startLine <= call.line && (sym.endLine || 0) >= call.line) {
-                                    endLine = Math.min(endLine, sym.endLine || endLine);
-                                }
-                            }
-                        }
-                        ranges.push({ start: call.line, end: endLine });
-                    }
-                    meta.jsTestRanges = ranges;
-                }
-            } catch (_) { /* ignore */ }
-        }
-        fileMeta.set(filePath, meta);
-        return meta;
-    }
+    const model = require('./test-units').createTestModel(index);
+    const kindOf = new Map();
     for (const site of sites) {
         site.inTestCase = false;
-        const meta = getFileMeta(site.callerFile);
-        if (!meta || !meta.langModule) continue;
-        // First: kinded entry-point predicate (Python/Go/Java/Rust + JS lifecycle).
-        const classify = meta.langModule.getEntryPointKind;
+        // A call in a test's own callback has no named function around it:
+        // the site's file is where it is.
+        const sitePath = site.callerFile ||
+            (site.file ? (path.isAbsolute(site.file) ? site.file : path.join(index.root, site.file)) : null);
+        const fileEntry = sitePath ? index.files.get(sitePath) : null;
+        if (!fileEntry) continue;
+        if (!kindOf.has(fileEntry.language)) {
+            let adapter = null;
+            try { adapter = getLanguageAdapter(fileEntry.language); } catch (_) { /* ignore */ }
+            kindOf.set(fileEntry.language, adapter && adapter.getEntryPointKind ? adapter.getEntryPointKind : null);
+        }
+        const classify = kindOf.get(fileEntry.language);
         if (classify && site.callerFile && site.callerStartLine != null) {
             const encl = index.findEnclosingFunction
                 ? index.findEnclosingFunction(site.callerFile, site.line, true)
@@ -157,15 +123,9 @@ function tagInTestCase(index, sites) {
                 continue;
             }
         }
-        // Second: JS/TS framework-call brackets (it/test/describe). The site is
-        // inside a test case when its line falls within a describe/it block.
-        if (meta.jsTestRanges && meta.jsTestRanges.length > 0 && site.line != null) {
-            for (const r of meta.jsTestRanges) {
-                if (site.line >= r.start && site.line <= r.end) {
-                    site.inTestCase = true;
-                    break;
-                }
-            }
+        if (site.line != null && isTestFile(fileEntry.relativePath, fileEntry.language) &&
+            model.unitAt(sitePath, site.line)) {
+            site.inTestCase = true;
         }
     }
 }
@@ -267,6 +227,16 @@ function tagCalleesSideEffects(index, callees) {
 }
 
 
+/**
+ * How many unverified entries get their line text and caller looked up: the
+ * rows a formatter prints. Every one with `all`, `top` when it asks for more
+ * than the default ten, the engine's default otherwise.
+ */
+function unverifiedEnrichLimit(all, top) {
+    if (all) return Infinity;
+    return Number.isInteger(top) && top > paramFact('top', 'unverifiedRows') ? top : undefined;
+}
+
 /**
  * Compose the conservation account for a caller query (the tiered
  * caller contract). Claims come from the PRE-display-filter findCallers result —
@@ -395,7 +365,8 @@ function context(index, name, options = {}) {
         // Pin caller resolution to the resolved class definition — same as the
         // function path below. Without this, same-name classes in other files
         // conflate (their usages attribute to whichever def displays).
-        let typeCallers = index.findCallers(name, { includeMethods, includeUncertain: options.includeUncertain, collectAccount: true, targetDefinitions: [def] });
+        let typeCallers = index.findCallers(name, { includeMethods, includeUncertain: options.includeUncertain, collectAccount: true, targetDefinitions: [def],
+            unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.maxCallers) });
         const rawTypeCallers = typeCallers;
         const typeFilteredByFlag = { exclude: 0, minConfidence: 0, unreachableOnly: 0 };
         // Tier partition — same contract as the function path: constructor/usage
@@ -457,7 +428,9 @@ function context(index, name, options = {}) {
             ...(typeAmbiguityCandidates && {
                 ambiguityCandidates: typeAmbiguityCandidates,
             }),
-            meta: { account: typeAccount, callerTotal }
+            meta: { account: typeAccount, callerTotal,
+                ...(options.all && { all: true }),
+                ...(options.maxCallers > 0 && { top: options.maxCallers }) }
         };
 
         if (warnings.length > 0) {
@@ -474,8 +447,9 @@ function context(index, name, options = {}) {
         stats,
         targetDefinitions: [def],
         collectAccount: true,
-        // --all lifts the unverified enrichment cap (content + caller lookup)
-        unverifiedEnrichLimit: options.all ? Infinity : undefined,
+        // --all lifts the unverified enrichment cap (content + caller
+        // lookup), --top moves it with the rows it prints.
+        unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.maxCallers),
     });
     // Callee side runs the contract too (v4): uncertain/unresolved calls in
     // the def's scope become VISIBLE unverifiedCallees entries + a conserved
@@ -630,6 +604,7 @@ function context(index, name, options = {}) {
                 hasEntrypoints: reachableSet.size > 0,
             }),
             ...(options.all && { all: true }),
+            ...(options.maxCallers > 0 && { top: options.maxCallers }),
             // Structural facts for reliability hints
             ...(def.isMethod && { isMethod: true }),
             ...(def.className && { className: def.className }),
@@ -758,28 +733,22 @@ function detectCompleteness(index) {
         // Skip node_modules - we don't care about their patterns
         if (filePath.includes('node_modules')) continue;
 
-        try {
-            const content = index._readFile(filePath);
-
-            if (langTraits(fileEntry.language)?.hasDynamicImports) {
-                // Dynamic imports: use the parser's structural count — the SAME
-                // source `doctor` uses — instead of a text regex. The old
-                // /import\s*\(/ matched Python grouped imports `from x import
-                // (...)`, flashing a false "N dynamic imports" incompleteness
-                // warning on essentially every Python project (field-report #2,
-                // reviewer-confirmed: doctor and about now agree on one count).
-                dynamicImports += fileEntry.dynamicImports || 0;
-            }
-
-            // eval/exec and reflection: the SAME shared counter doctor uses, so
-            // the about footer and the trust report never diverge (field-report #2).
-            const bs = countTextBlindspots(content, fileEntry.language);
-            evalUsage += bs.eval;
-            reflectionUsage += bs.reflection;
-            computedDispatchUsage += computedDispatch.get(filePath)?.length || 0;
-        } catch (e) {
-            // Skip unreadable files
+        if (langTraits(fileEntry.language)?.hasDynamicImports) {
+            // Dynamic imports: use the parser's structural count — the SAME
+            // source `doctor` uses — instead of a text regex. The old
+            // /import\s*\(/ matched Python grouped imports `from x import
+            // (...)`, flashing a false "N dynamic imports" incompleteness
+            // warning on essentially every Python project (field-report #2,
+            // reviewer-confirmed: doctor and about now agree on one count).
+            dynamicImports += fileEntry.dynamicImports || 0;
         }
+
+        // eval/exec and reflection: the two numbers `doctor` reports, counted
+        // in each file's tree when it was indexed (core/reflection.js), so
+        // the footer and the trust report never diverge and no file is read.
+        evalUsage += fileEntry.evalUses || 0;
+        reflectionUsage += fileEntry.reflectionUses || 0;
+        computedDispatchUsage += computedDispatch.get(filePath)?.length || 0;
     }
 
     if (dynamicImports > 0) {
@@ -1204,6 +1173,7 @@ function impact(index, name, options = {}) {
             includeUncertain: impactIncludeUncertain,
             targetDefinitions: [def],
             collectAccount: true,
+            unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.top),
         });
         impactAccountRaw = callerResults.accountRaw;
         impactRoutedUnverified = callerResults.unverifiedEntries || [];
@@ -1251,6 +1221,7 @@ function impact(index, name, options = {}) {
             includeUncertain: impactIncludeUncertain,
             targetDefinitions: [def],
             collectAccount: true,
+            unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.top),
         });
         impactAccountRaw = callerResults.accountRaw;
         impactRoutedUnverified = callerResults.unverifiedEntries || [];
@@ -1717,7 +1688,8 @@ function about(index, name, options = {}) {
         // BUG-H1: pass needsTotal:true so the returned array's `totalCount` reflects the
         // true pre-truncation candidate count. Without this, `about` would report the
         // capped count as the total (e.g. "showing 10 of 30" when there are actually 153).
-        const rawCallers = index.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary], maxResults: callerCap, needsTotal: true, collectAccount: true });
+        const rawCallers = index.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary], maxResults: callerCap, needsTotal: true, collectAccount: true,
+            unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.maxCallers) });
         const shadowCallers = rawCallers.shadowEntries || [];
         allCallers = rawCallers;
         const aboutFilteredByFlag = { exclude: 0, minConfidence: 0, unreachableOnly: 0 };
@@ -1838,9 +1810,18 @@ function about(index, name, options = {}) {
             if (fa !== fb) return codeUnitCompare(fa, fb);
             return (a.line || 0) - (b.line || 0);
         });
+        // Every unverified entry's reason, counted: the listed rows are a part.
+        const unverifiedReasons = {};
+        for (const entry of unverifiedPool) {
+            const reason = entry.reason || 'unknown';
+            unverifiedReasons[reason] = (unverifiedReasons[reason] || 0) + 1;
+        }
         aboutUnverified = {
             total: unverifiedPool.length + unverifiedShadowCount,
-            top: unverifiedPool.slice(0, 10).map(c => ({
+            reasons: Object.fromEntries(Object.keys(unverifiedReasons).sort(codeUnitCompare)
+                .map(reason => [reason, unverifiedReasons[reason]])),
+            top: unverifiedPool.slice(0, options.all ? Infinity
+                : options.maxCallers > 0 ? options.maxCallers : 10).map(c => ({
                 file: c.relativePath,
                 line: c.line,
                 ...(c.callerStartLine && c.callerName && {
@@ -2054,6 +2035,79 @@ function about(index, name, options = {}) {
     } finally { index._endOp(); }
 }
 
+/**
+ * What one revision of a file, and the project, say about the callees a
+ * body calls as bare statements (core/change-kinds.js `provablyReturns`).
+ *
+ *   fileNames   every name the revision declares or imports: a builtin of
+ *               that name means something else there;
+ *   returning   (name, ownerClass) => every declaration the name can mean
+ *               is one a call of which returns (`declaresPlainReturn`): a
+ *               function the revision declares, or imports by name from a
+ *               project module, or the method its own class declares.
+ *
+ * Declarations are read as the project holds them now, for both revisions:
+ * a callee whose own declaration changed is a changed symbol of its own.
+ *
+ * @param {Map} cache - facts by file entry, kept for ONE diff: what a
+ *   callee declares can change between two diffs of the same index
+ */
+const NAMED_IMPORT_KINDS = new Set(['named', 'from']);
+function calleeFacts(index, entry, filePath, cache) {
+    if (!entry) return null;
+    if (cache.has(entry)) return cache.get(entry);
+    const live = index.files.get(filePath);
+    const traits = langTraits(live && live.language) || {};
+    const fileNames = new Set();
+    for (const symbol of entry.symbols || []) fileNames.add(symbol.name);
+    for (const binding of entry.importBindings || []) fileNames.add(binding.alias || binding.name);
+    const plain = definition => {
+        const owner = index.files.get(definition.file);
+        const never = owner && langTraits(owner.language)?.neverReturnTypes;
+        if (!Array.isArray(never)) return false;
+        try {
+            const content = index._readFile(definition.file);
+            const root = index._getParsedTree(definition.file, content, owner.language)?.rootNode ||
+                parseRevision(content, owner.language);
+            return declaresPlainReturn(root, definition, never);
+        } catch (_) {
+            return false;
+        }
+    };
+    const allPlain = (name, mine) => {
+        const definitions = (index.symbols.get(name) || []).filter(mine);
+        return definitions.length > 0 && definitions.every(plain);
+    };
+    const verdicts = new Map();
+    const facts = {
+        fileNames,
+        returning(name, ownerClass) {
+            if (!Array.isArray(traits.neverReturnTypes)) return false;
+            const key = `${ownerClass || ''}\0${name}`;
+            if (verdicts.has(key)) return verdicts.get(key);
+            let verdict;
+            if (ownerClass) {
+                verdict = (entry.symbols || []).some(symbol => symbol.name === name && symbol.className === ownerClass) &&
+                    allPlain(name, definition => definition.className === ownerClass && definition.file === filePath);
+            } else {
+                let declared = (entry.symbols || []).some(symbol => symbol.name === name && !symbol.className) ? name : null;
+                if (!declared) {
+                    const resolved = (live && live.moduleResolved) || {};
+                    const binding = (entry.importBindings || []).find(candidate =>
+                        (candidate.alias || candidate.name) === name && NAMED_IMPORT_KINDS.has(candidate.kind) &&
+                        resolved[candidate.module]);
+                    if (binding) declared = binding.name;
+                }
+                verdict = !!declared && allPlain(declared, definition => !definition.className);
+            }
+            verdicts.set(key, verdict);
+            return verdict;
+        },
+    };
+    cache.set(entry, facts);
+    return facts;
+}
+
 /**
  * Diff-based impact analysis: find which functions changed and who calls them.
  *
@@ -2065,6 +2119,10 @@ function diffImpact(index, options = {}) {
     index._beginOp();
     try {
     const { base = 'HEAD', staged = false, file } = options;
+    // Where git commands run. The index's own root, except for a snapshot
+    // exported from the git index (core/snapshot.js): its files stand in
+    // for the repository's, and the repository is elsewhere.
+    const repoRoot = options.repoRoot || index.repoRoot || index.root;
 
     // Validate base ref format to prevent argument injection
     if (base && !/^[a-zA-Z0-9._\-~\/^@{}:]+$/.test(base)) {  // eslint-disable-line no-useless-escape
@@ -2074,7 +2132,7 @@ function diffImpact(index, options = {}) {
     // Verify git repo
     let gitRoot;
     try {
-        gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: index.root, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: repoRoot, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
     } catch (e) {
         throw new UcnError('Not a git repository. impact without a symbol requires git.', { cause: e });
     }
@@ -2096,7 +2154,7 @@ function diffImpact(index, options = {}) {
         // "fatal: ambiguous argument" straight to the terminal AND repeat it
         // inside the error message.
         diffText = execFileSync('git', diffArgs, {
-            cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024,
+            cwd: repoRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
     } catch (e) {
@@ -2115,7 +2173,7 @@ function diffImpact(index, options = {}) {
     // Normalize both through realpath to handle macOS /var → /private/var symlinks.
     let realGitRoot, realProjectRoot;
     try { realGitRoot = fs.realpathSync(gitRoot); } catch (_) { realGitRoot = gitRoot; }
-    try { realProjectRoot = fs.realpathSync(index.root); } catch (_) { realProjectRoot = index.root; }
+    try { realProjectRoot = fs.realpathSync(repoRoot); } catch (_) { realProjectRoot = repoRoot; }
     const projectPrefix = realGitRoot === realProjectRoot
         ? ''
         : path.relative(realGitRoot, realProjectRoot);
@@ -2143,7 +2201,7 @@ function diffImpact(index, options = {}) {
         let untrackedText = '';
         try {
             untrackedText = execFileSync('git', lsArgs, {
-                cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024,
+                cwd: repoRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024,
                 stdio: ['ignore', 'pipe', 'ignore'],
             });
         } catch (_) { untrackedText = ''; }
@@ -2192,6 +2250,13 @@ function diffImpact(index, options = {}) {
 
     const functions = [];
     const moduleLevelChanges = [];
+    // What each changed file did outside its declarations: names it no
+    // longer provides to importers, import statements, loose module code.
+    const moduleChanges = [];
+    // Files the diff removed: whoever imports one as a module lost it.
+    const deletedFiles = [];
+    const addedFiles = [];
+    const calleeFactsByEntry = new Map();
     const newFunctions = [];
     const deletedFunctions = [];
     const symbolChanges = { symbols: [], newSymbols: [], deletedSymbols: [] };
@@ -2214,22 +2279,24 @@ function diffImpact(index, options = {}) {
 
         // Handle deleted files: entire file was removed, all functions are deleted
         if (!fileEntry) {
+            if (change.isDeleted) deletedFiles.push(change.relativePath);
             if (change.isDeleted && change.deletedLines.length > 0) {
                 const ref = staged ? 'HEAD' : base;
                 try {
                     const oldContent = execFileSync(
                         'git', ['show', `${ref}:${change.gitRelativePath}`],
-                        { cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
+                        { cwd: repoRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
                     );
                     const oldParsed = parse(oldContent, lang);
-                    collectNonCallableChanges(index, change, oldParsed, [], symbolChanges);
+                    collectNonCallableChanges(index, change, oldParsed, [], symbolChanges, null, options);
+                    const baseEntry = index.fileEntryForContent(change.filePath, oldContent);
                     for (const oldFn of extractCallableSymbols(oldParsed)) {
-                        deletedFunctions.push({
+                        deletedFunctions.push(withBaseDeclaration({
                             name: oldFn.name,
                             filePath: change.filePath,
                             relativePath: change.relativePath,
                             startLine: oldFn.startLine
-                        });
+                        }, baseEntry, oldFn));
                     }
                 } catch (e) {
                     // git show failed — skip
@@ -2237,6 +2304,8 @@ function diffImpact(index, options = {}) {
             }
             continue;
         }
+        // A file that did not exist at the base.
+        if (change.untracked || change.isNew) addedFiles.push(fileEntry.relativePath);
 
         // Track which functions are affected by added/modified lines
         const affectedSymbols = new Map(); // symbolName -> { symbol, addedLines, deletedLines }
@@ -2255,7 +2324,7 @@ function diffImpact(index, options = {}) {
             try {
                 const oldContent = execFileSync(
                     'git', ['show', `${ref}:${change.gitRelativePath}`],
-                    { cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
+                    { cwd: repoRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
                 );
                 const fileLang = index.languageOf(change.filePath);
                 if (fileLang) {
@@ -2273,7 +2342,33 @@ function diffImpact(index, options = {}) {
             }
         }
 
-        collectNonCallableChanges(index, change, oldParsed, fileEntry.symbols, symbolChanges, oldLines);
+        collectNonCallableChanges(index, change, oldParsed, fileEntry.symbols, symbolChanges, oldLines, options);
+
+        // The base revision read with the index's own eyes, and both
+        // revisions' syntax trees: what a changed callable's contract was
+        // and is (core/change-kinds.js). Built on first use.
+        let baseEntry;
+        const baseEntryOf = () => {
+            if (baseEntry === undefined) baseEntry = oldText != null ? index.fileEntryForContent(change.filePath, oldText) : null;
+            return baseEntry;
+        };
+        let baseRoot;
+        let currentRoot;
+        const contractChange = symbol => {
+            if (change.untracked || oldText == null) return { kind: 'unknown', reasons: ['contract-unreadable'] };
+            const fileLang = fileEntry.language;
+            if (baseRoot === undefined) baseRoot = parseRevision(oldText, fileLang);
+            if (currentRoot === undefined) {
+                let content;
+                try { content = index._readFile(change.filePath); } catch { content = null; }
+                currentRoot = content == null ? null
+                    : (index._getParsedTree(change.filePath, content, fileLang)?.rootNode || parseRevision(content, fileLang));
+            }
+            const base = baseCounterpart(baseEntryOf()?.symbols, symbol, isDiffCallable);
+            return classifyChange(
+                base ? callableContract(baseRoot, fileLang, base, calleeFacts(index, baseEntryOf(), change.filePath, calleeFactsByEntry)) : null,
+                callableContract(currentRoot, fileLang, symbol, calleeFacts(index, fileEntry, change.filePath, calleeFactsByEntry)), fileLang);
+        };
 
         // Several callables can share a changed line (`class Box {
         // constructor(v) {..} get w() {..} }`, fix #434): the line belongs
@@ -2474,7 +2569,10 @@ function diffImpact(index, options = {}) {
                     relativePath: change.relativePath,
                     startLine: symbol.startLine,
                     endLine: symbol.endLine,
-                    signature: index.formatSignature(symbol)
+                    signature: index.formatSignature(symbol),
+                    ...(symbol.className && { className: symbol.className }),
+                    // Nothing in a file the base does not have existed before.
+                    ...((change.untracked || change.isNew) && { newFile: true }),
                 });
                 affectedSymbols.delete(key);
             }
@@ -2505,17 +2603,57 @@ function diffImpact(index, options = {}) {
                     // Report the extra ones (by startLine descending — later ones more likely deleted)
                     const toReport = matching.slice(curCount);
                     for (const oldFn of toReport) {
-                        deletedFunctions.push({
+                        deletedFunctions.push(withBaseDeclaration({
                             name: oldFn.name,
                             filePath: change.filePath,
                             relativePath: change.relativePath,
                             startLine: oldFn.startLine
-                        });
+                        }, baseEntryOf(), oldFn));
                     }
                 }
             }
         }
 
+        // Outside the declarations: what the module provides and what it
+        // runs. Both revisions are needed; a new file has no "before".
+        if (oldText != null && !change.untracked) {
+            const fileLang = fileEntry.language;
+            const before = { fileEntry: baseEntryOf(), root: parseRevision(oldText, fileLang) };
+            let currentContent;
+            try { currentContent = index._readFile(change.filePath); } catch { currentContent = null; }
+            // Like with like: both revisions as the parser alone records
+            // them. The live entry also holds what later build phases add
+            // (declarations a macro invocation expands to), which no base
+            // entry has, and a macro invocation would read as code that
+            // exists only before.
+            const after = {
+                fileEntry: currentContent == null ? null : index.fileEntryForContent(change.filePath, currentContent),
+                root: currentContent == null ? null : parseRevision(currentContent, fileLang),
+            };
+            if (before.fileEntry && before.root && after.fileEntry && after.root) {
+                const moved = moduleChange(before, after, langTraits(fileLang) || {});
+                const gone = new Set(deletedFunctions.filter(item => item.filePath === change.filePath).map(item => item.name));
+                for (const item of symbolChanges.deletedSymbols) {
+                    if (item.filePath === change.filePath) gone.add(item.name);
+                }
+                // A deleted declaration's name is assessed as a deletion.
+                const removedNames = moved.removedNames.filter(name => !gone.has(name));
+                if (removedNames.length > 0 || moved.importsRemoved > 0 || moved.importsAdded > 0 ||
+                    moved.codeChanged || moved.starExportRemoved || moved.reboundBindings.length > 0) {
+                    moduleChanges.push({
+                        filePath: change.filePath,
+                        relativePath: change.relativePath,
+                        ...moved,
+                        removedNames,
+                        removedExports: moved.removedExports.filter(name => !gone.has(name)),
+                        // Does a newly imported name already mean something in the file?
+                        shadowed: moved.addedBindings.filter(name =>
+                            new RegExp(`(?<![\\w$])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w$])`).test(oldText)),
+                    });
+                }
+            }
+        }
+
         // For each affected function, find callers under the tiered caller
         // contract (v4): confirmed edges populate `callers`; evidence-less
         // candidates render in `unverifiedCallers` with reasons; positively
@@ -2534,6 +2672,7 @@ function diffImpact(index, options = {}) {
                 targetDefinitions: targetDefs.length > 0 ? targetDefs : undefined,
                 includeMethods: true,
                 collectAccount: true,
+                unverifiedEnrichLimit: unverifiedEnrichLimit(options.all, options.top),
             });
             // Call sites the base declaration bound that the changed one's
             // sweep excludes (fix #394) are the change's likeliest breaks:
@@ -2591,6 +2730,9 @@ function diffImpact(index, options = {}) {
                 signature: index.formatSignature(symbol),
                 addedLines: aLines,
                 deletedLines: dLines,
+                // What the change did to the contract callers rely on:
+                // 'inert', 'contract' (with what moved) or 'unknown'.
+                change: contractChange(symbol),
                 callers: confirmed.map(c => ({
                     file: c.file,
                     relativePath: c.relativePath,
@@ -2688,7 +2830,13 @@ function diffImpact(index, options = {}) {
         for (const site of refs?.unverifiedSites || []) dependencyFiles.add(site.file);
     }
 
-    return {
+    // Which lines of which file the diff added: what "outside this change"
+    // means for a name. Not enumerable: the report's shape is unchanged.
+    const addedLinesByFile = new Map();
+    for (const change of changes) {
+        if (change.addedLines.length > 0) addedLinesByFile.set(change.relativePath, new Set(change.addedLines));
+    }
+    const report = Object.defineProperty({
         base: staged ? '(staged)' : base,
         changedPaths: changes.length,
         nonSourcePaths,
@@ -2712,13 +2860,30 @@ function diffImpact(index, options = {}) {
             unverifiedCallSites: totalUnverifiedSites,
             affectedFiles: callerFileSet.size
         }
-    };
+    }, 'addedLinesByFile', { value: addedLinesByFile, enumerable: false });
+    Object.defineProperty(report, 'moduleChanges', { value: moduleChanges, enumerable: false });
+    Object.defineProperty(report, 'deletedFiles', { value: deletedFiles, enumerable: false });
+    Object.defineProperty(report, 'addedFiles', { value: addedFiles, enumerable: false });
+    return report;
     } finally { index._endOp(); }
 }
 
+/**
+ * A deleted callable keeps the declaration it was: the base revision's own
+ * record and that revision's file facts, for a deletion assessment
+ * (core/deletion.js). Not enumerable: the report's shape is unchanged.
+ */
+function withBaseDeclaration(item, baseEntry, oldSymbol) {
+    const declaration = (baseEntry?.symbols || []).find(symbol => symbol.name === oldSymbol.name &&
+        (symbol.className || '') === (oldSymbol.className || '') && symbol.startLine === oldSymbol.startLine);
+    Object.defineProperty(item, 'declaration', { value: declaration || null, enumerable: false });
+    Object.defineProperty(item, 'baseFileEntry', { value: baseEntry || null, enumerable: false });
+    return item;
+}
+
 // Non-callable declarations have change dependencies too. Keep them separate
 // from functions so type references never inflate call-site accounting.
-function collectNonCallableChanges(index, change, oldParsed, currentSymbols, output, oldLines = null) {
+function collectNonCallableChanges(index, change, oldParsed, currentSymbols, output, oldLines = null, options = {}) {
     const nonCallable = s => NON_CALLABLE_TYPES.has(s.type) || s.type === 'record';
     const oldSymbols = [];
     for (const cls of oldParsed?.classes || []) {
@@ -2770,6 +2935,7 @@ function collectNonCallableChanges(index, change, oldParsed, currentSymbols, out
         } else {
             item.impact = impact(index, symbol.name, {
                 file: change.relativePath, line: symbol.startLine, className: symbol.className,
+                all: options.all, top: options.top,
             });
         }
         output[kind].push(item);

package/core/ast-analysis.js

@@ -437,6 +437,8 @@ function projectReflectionSites(index) {
 }
 
 module.exports = {
+    CALLABLE_NODES,
+    COMMENT_NODES,
     declarationSnapshots,
     computeAstComplexity,
     computedDispatchSites,