ucn 4.1.1 → 4.1.3

package/core/deadcode.js

@@ -53,32 +53,90 @@ function _baseIsExternal(index, bare, lang) {
     return !(defs && defs.some(d => _CLASS_KINDS.includes(d.type)));
 }
 
-/** Does this CLASS DEF extend at least one base that is not in the project index? */
-function _classDefHasExternalBase(index, classDef, lang) {
-    if (!classDef.extends) return false;
-    const supers = Array.isArray(classDef.extends) ? classDef.extends : splitParentList(classDef.extends);
-    return supers.some(raw => _baseIsExternal(index, _bareBaseName(raw), lang));
-}
+// Bounded heritage-closure depth (fix #270) — matches the engine's other
+// inheritance walks.
+const _HERITAGE_WALK_DEPTH = 8;
 
 /**
- * Does the method's enclosing class EXTEND at least one base that is NOT in the
- * project index? An out-of-tree base is a framework/library type UCN can't see;
- * via inheritance it may dispatch into a public method of the subclass
- * polymorphically (Starlette → build_middleware_stack) or by name convention
- * (Pydantic → bytes_schema). The class def is matched in the method's own file.
+ * Does this CLASS DEF reach at least one base that is NOT in the project
+ * index, walking `extends` chains transitively THROUGH resolved project types
+ * (fix #270)? One level was not enough — fastify-measured: CustomLoggerImpl
+ * implements CustomLogger (project) extends FastifyBaseLogger (project,
+ * .d.ts) extends Pick<BaseLogger, ...'silent'> (pino — external). The member
+ * surface the class must provide comes from the OUT-OF-TREE end of the chain,
+ * invisible without tsc, so a zero-usage impl member (`silent`) is contract
+ * surface — deleting it breaks the build. Same dispatch physics as one level;
+ * only the verdict moved from "direct parent external" to "heritage closure
+ * reaches external".
  *
- * `implements` is deliberately NOT consulted: implementing an external
- * interface/trait makes only the INTERFACE'S OWN methods a contract (those
- * carry traitImpl/@Override markers → handled by Rule A), not the class's
- * unrelated inherent methods. Counting it would wrongly shield, e.g., a Rust
- * struct's genuinely-dead inherent method just because the struct also
- * `impl Display for`s.
+ * `followImplements` additionally walks the def's OWN `implements` clause
+ * (first hop only — the measured family; deeper implements hops are
+ * classified-deferred). Method claims pass true only when the member sits
+ * INSIDE the def's source range: TS/Java members live in the class body, so
+ * the implements contract constrains them. Rust surfaces trait impls as
+ * `implements` on the struct (rust.js), but inherent methods live in separate
+ * `impl X` blocks OUTSIDE the struct's range — an unrelated `impl Display
+ * for X` must never shield a genuinely-dead inherent method (the original
+ * reason implements was not consulted here at all; trait-impl members
+ * themselves carry traitImpl/@Override markers → Rule A). Class-kind claims
+ * pass false: deleting the whole class removes its implements clause with it.
+ */
+function _heritageReachesExternalBase(index, classDef, lang, followImplements) {
+    const seen = new Set();
+    let frontier = [classDef];
+    for (let depth = 0; depth < _HERITAGE_WALK_DEPTH && frontier.length; depth++) {
+        const next = [];
+        for (const def of frontier) {
+            // Copy array-shaped extends — the implements push below must
+            // never mutate the symbol's own heritage data in the index.
+            const parents = def.extends
+                ? (Array.isArray(def.extends) ? [...def.extends] : splitParentList(def.extends))
+                : [];
+            if (depth === 0 && followImplements && Array.isArray(def.implements)) {
+                parents.push(...def.implements);
+            }
+            for (const raw of parents) {
+                const bare = _bareBaseName(raw);
+                if (!bare || seen.has(bare)) continue;
+                seen.add(bare);
+                if (_baseIsExternal(index, bare, lang)) return true;
+                for (const pd of index.symbols.get(bare) || []) {
+                    if (_CLASS_KINDS.includes(pd.type)) next.push(pd);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return false;
+}
+
+/**
+ * Does the method's enclosing class reach at least one base that is NOT in
+ * the project index through its heritage closure? An out-of-tree base is a
+ * framework/library type UCN can't see; via inheritance it may dispatch into
+ * a public method of the subclass polymorphically (Starlette →
+ * build_middleware_stack), by name convention (Pydantic → bytes_schema), or
+ * REQUIRE the member outright (fastify → CustomLoggerImpl.silent, via an
+ * implements chain ending in pino). The class def is matched in the method's
+ * own file; `implements` is walked only when the member sits inside the class
+ * def's own range (see _heritageReachesExternalBase — the Rust guard).
  */
 function _classHasExternalBase(index, symbol) {
     const lang = index.files.get(symbol.file)?.language;
+    // The implements hop shields only contract-SATISFIABLE members: an
+    // interface implementation must be public, so in explicit-visibility
+    // languages a package-private/non-pub member provably cannot implement
+    // any interface member (javac rejects it) — `implements Runnable` never
+    // shields a package-private helper. Implicit-public languages satisfy
+    // contracts with unmarked members; the caller's public-by-shape check
+    // already screened those. Compiler physics, not a heuristic.
+    const contractSatisfiable = langTraits(lang)?.implicitlyPublicMembers ||
+        (symbol.modifiers || []).includes('public');
     const classDefs = (index.symbols.get(symbol.className) || []).filter(c =>
         c.file === symbol.file && _CLASS_KINDS.includes(c.type));
-    return classDefs.some(cd => _classDefHasExternalBase(index, cd, lang));
+    return classDefs.some(cd => _heritageReachesExternalBase(index, cd, lang,
+        contractSatisfiable &&
+        symbol.startLine >= cd.startLine && symbol.startLine <= cd.endLine));
 }
 
 /**
@@ -92,9 +150,12 @@ function _classHasExternalBase(index, symbol) {
  *       Rust `impl Trait for X`) AND a single project-wide method owner of the
  *       name (no in-project supertype defines it → the contract is external —
  *       the #210 ownerCount===1 rule).
- *   (B) a public-by-shape method whose class EXTENDS an unresolved base.
- *       Private/underscore members are never external-contract surface, so a
- *       genuinely-dead one stays claimable (the fix #211 shape predicate).
+ *   (B) a public-by-shape method whose class reaches an unresolved base
+ *       through its heritage closure (extends chains walked transitively,
+ *       plus the class's own `implements` clause when the member sits in the
+ *       class body — fix #270). Private/underscore members are never
+ *       external-contract surface, so a genuinely-dead one stays claimable
+ *       (the fix #211 shape predicate).
  * Data-driven, not language-keyed: classes without an `extends` clause (Go
  * embedding, Rust structs / inherent impls) never trip (B), and Rust trait
  * impls trip (A) via traitImpl — so new languages inherit correct behavior.
@@ -161,17 +222,52 @@ function nameOnlySelfRecursive(index, name) {
     return true;
 }
 
-/** Check if a position in a line is inside a string literal (quotes/backticks) */
-function isInsideString(line, pos) {
+/** Check if a position in a line is inside a string literal (quotes/backticks).
+ *  Language-aware (fix #259, clap-measured): a Rust apostrophe is a LIFETIME
+ *  unless it closes as a char literal within a few chars — `impl<E: Send +
+ *  'static> MyTrait` read everything after 'static as "inside a string" and
+ *  dropped the line's only reference to MyTrait (FALSE-DEAD on clap's
+ *  autoref-specialization traits). */
+function isInsideString(line, pos, language) {
     let inSingle = false, inDouble = false, inBacktick = false;
+    // Template-literal interpolations are CODE (fix #267, hono-measured:
+    // `${this.activeRouter.name}` was the getter's ONLY read — masked as
+    // string interior, the symbol claimed FALSE-DEAD). JS family only: Go
+    // backtick strings are raw, no interpolation. Brace-depth tracked so
+    // `${ {a: 1} }` closes at the right brace; quotes inside interpolations
+    // are not tracked — the misjudgment direction is UNMASK (counting a
+    // usage keeps the symbol alive), never masking code (#253 rule).
+    let interpDepth = 0;
+    const jsTemplates = language === 'javascript' || language === 'typescript' ||
+        language === 'tsx' || language === 'html';
     for (let j = 0; j < pos; j++) {
         const ch = line[j];
         if (ch === '\\') { j++; continue; }
+        if (inBacktick && jsTemplates) {
+            if (interpDepth === 0) {
+                if (ch === '$' && line[j + 1] === '{') { interpDepth = 1; j++; }
+                else if (ch === '`') inBacktick = false;
+                continue;
+            }
+            if (ch === '{') interpDepth++;
+            else if (ch === '}') interpDepth--;
+            continue;
+        }
         if (ch === '"' && !inSingle && !inBacktick) inDouble = !inDouble;
-        if (ch === "'" && !inDouble && !inBacktick) inSingle = !inSingle;
+        if (ch === "'" && !inDouble && !inBacktick) {
+            if (language === 'rust') {
+                // Char literal ('x', '\n', '\u{1F600}') — skip past it; a
+                // non-closing apostrophe is a lifetime and never opens a
+                // string (Rust strings are double-quoted only).
+                const m = line.slice(j).match(/^'(?:\\u\{[0-9a-fA-F_]+\}|\\.|[^'\\])'/);
+                if (m) j += m[0].length - 1;
+            } else {
+                inSingle = !inSingle;
+            }
+        }
         if (ch === '`' && !inDouble && !inSingle) inBacktick = !inBacktick;
     }
-    return inSingle || inDouble || inBacktick;
+    return inSingle || inDouble || (inBacktick && interpDepth === 0);
 }
 
 /**
@@ -591,9 +687,16 @@ function deadcode(index, options = {}) {
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];
                         if (!line.includes(name)) continue;
-                        // Skip line if entirely inside a line comment (// or #)
-                        const commentIdx = line.indexOf('//');
-                        const hashIdx = line.indexOf('#');
+                        // Skip line if entirely inside a line comment — the
+                        // markers are language-shaped (fix #259, clap-measured):
+                        // `#` comments PYTHON ONLY (a Rust attribute line
+                        // `#[arg(value_parser = helper)]` is code, and the old
+                        // skip dropped every reference on it — clap's derive-
+                        // attribute callbacks claimed FALSE-DEAD); `//` comments
+                        // everywhere EXCEPT Python, where it is floor division.
+                        const isPython = fileEntry.language === 'python';
+                        const commentIdx = isPython ? -1 : line.indexOf('//');
+                        const hashIdx = isPython ? line.indexOf('#') : -1;
                         let searchFrom = 0;
                         while (searchFrom < line.length) {
                             const pos = line.indexOf(name, searchFrom);
@@ -611,7 +714,7 @@ function deadcode(index, options = {}) {
                             // Skip if inside a string literal — EXCEPT class-
                             // kind names in Python (fix #253a): `x: "Foo"`
                             // forward references are real type references.
-                            if (isInsideString(line, pos) &&
+                            if (isInsideString(line, pos, fileEntry.language) &&
                                 !(fileEntry.language === 'python' && classKindNames.has(name))) continue;
                             // Property/field access (preceded by '.'), not a
                             // call: resolve the RECEIVER (fix #216, express-
@@ -778,6 +881,15 @@ function deadcode(index, options = {}) {
 
             const mods = symbol.modifiers || [];
 
+            // Ambient declaration files are never dead CODE (fix #267,
+            // zustand-measured: `interface ImportMeta` in src/types.d.ts —
+            // global lib merging UCN cannot see): .d.ts content is erased at
+            // compile time and describes external/global shapes — nothing in
+            // it is deletable code, so nothing in it is claimable.
+            if (symbol.relativePath.endsWith('.d.ts')) {
+                continue;
+            }
+
             // Language-specific entry points (called by runtime/test runner, not user code)
             // Each language module declares its own isEntryPoint() rules.
             const langModule = getLanguageModule(lang);
@@ -899,7 +1011,7 @@ function deadcode(index, options = {}) {
                 // by module path, pytest plugins by registration) — zero
                 // in-project references is not evidence of deadness there.
                 const isExternalContract = classAuditSet.has(symbol.type)
-                    ? _classDefHasExternalBase(index, symbol, lang)
+                    ? _heritageReachesExternalBase(index, symbol, lang, false)
                     : overridesOutOfTreeBase(index, symbol);
                 if (isExternalContract && !options.includeExported) {
                     excludedExternalContract++;

package/core/entrypoints.js

@@ -1104,6 +1104,12 @@ function computeReachability(index) {
         }
     }
 
+    // The BFS runs thousands of findCallees calls — the per-operation caches
+    // (call counts, usage totals, content) halve its cost. Wrap so callers
+    // outside a command op (evals, direct API use) get the same warm path;
+    // _beginOp nests, so command-op callers are unaffected.
+    index._beginOp?.();
+    try {
     const reachable = new Set();
     const entryPoints = detectEntrypoints(index);
 
@@ -1208,8 +1214,10 @@ function computeReachability(index) {
 
     // BFS: walk callees of every reachable symbol.
     // findCallees returns full symbol objects for every callee with file/startLine.
-    while (queue.length > 0) {
-        const sym = queue.shift();
+    // Index-based traversal — queue.shift() is O(n) per dequeue and the
+    // queue reaches thousands of entries; same FIFO order.
+    for (let qi = 0; qi < queue.length; qi++) {
+        const sym = queue[qi];
         if (!sym.file || sym.startLine == null) continue;
 
         let callees;
@@ -1242,6 +1250,9 @@ function computeReachability(index) {
     // Cleared in saveCache after a successful write.
     index.reachabilityDirty = true;
     return reachable;
+    } finally {
+        index._endOp?.();
+    }
 }
 
 /**

package/core/imports.js

@@ -145,6 +145,15 @@ function resolveImport(importPath, fromFile, config = {}) {
             const fullPath = path.join(config.root, modulePath);
             const resolved = resolveFilePath(fullPath, getExtensions('python'));
             if (resolved) return resolved;
+            // PEP-517 src layout (fix #269, click-measured): the installed
+            // package lives under src/ — `import click` from tests/ resolves
+            // to src/click/__init__.py. Without this, the module-ownership
+            // discipline judged the project's OWN package provably external
+            // (excluded every `click.get_binary_stream(...)` test caller —
+            // a false zero-caller answer).
+            const srcPath = path.join(config.root, 'src', modulePath);
+            const srcResolved = resolveFilePath(srcPath, getExtensions('python'));
+            if (srcResolved) return srcResolved;
         }
 
         return null;  // External package
@@ -289,6 +298,42 @@ function resolveGoImport(importPath, fromFile, projectRoot) {
 // Cache for Rust crate roots (Cargo.toml locations)
 const cargoCache = new Map();
 
+// Workspace crate registry (fix #258): Cargo [package] name → crate source
+// root for EVERY crate in the project tree, so cross-crate workspace imports
+// (`use clap::Command` from clap_bench/) resolve like own-package imports.
+// One bounded scan per project root, cached.
+const workspaceCrateCache = new Map();
+const _WORKSPACE_SCAN_PRUNE = new Set([
+    'node_modules', '.git', 'target', 'vendor', 'dist', 'build', '.ucn-cache',
+]);
+
+function workspaceCrateRegistry(projectRoot) {
+    if (workspaceCrateCache.has(projectRoot)) {
+        return workspaceCrateCache.get(projectRoot);
+    }
+    const registry = new Map();
+    const walk = (dir, depth) => {
+        if (depth > 6) return;
+        let entries;
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+        catch { return; }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (_WORKSPACE_SCAN_PRUNE.has(e.name) || e.name.startsWith('.')) continue;
+                walk(path.join(dir, e.name), depth + 1);
+            } else if (e.name === 'Cargo.toml') {
+                const info = findCargoRoot(dir);
+                if (info && info.packageName && !registry.has(info.packageName)) {
+                    registry.set(info.packageName, info);
+                }
+            }
+        }
+    };
+    walk(projectRoot, 0);
+    workspaceCrateCache.set(projectRoot, registry);
+    return registry;
+}
+
 /**
  * Find the nearest Cargo.toml and return the crate's source root
  * @param {string} startDir - Directory to start searching from
@@ -311,13 +356,24 @@ function findCargoRoot(startDir) {
             // integration tests/benches/examples (`use mypkg::...` in
             // tests/*.rs — fix #246); `-` normalizes to `_` in code.
             let packageName = null;
+            const targetDirs = [];
             try {
                 const toml = fs.readFileSync(cargoPath, 'utf-8');
                 const pkgSection = toml.split(/^\s*\[/m).find(s => s.startsWith('package]'));
                 const m = pkgSection && pkgSection.match(/^\s*name\s*=\s*"([^"]+)"/m);
                 if (m) packageName = m[1].replace(/-/g, '_');
+                // Explicit target roots (fix #260b, ripgrep-measured): a
+                // manifest may root its targets OUTSIDE src/ — ripgrep's
+                // `[[bin]] path = "crates/core/main.rs"` puts the whole bin
+                // module tree under crates/core, so `crate::messages` from
+                // crates/core/flags/parse.rs resolves THERE, never at src/.
+                // Collect every declared .rs target path's directory.
+                for (const tm of toml.matchAll(/^\s*path\s*=\s*"([^"]+\.rs)"/gm)) {
+                    const tDir = path.dirname(path.resolve(dir, tm[1]));
+                    if (!targetDirs.includes(tDir)) targetDirs.push(tDir);
+                }
             } catch { /* unreadable Cargo.toml — no package identity */ }
-            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName };
+            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName, targetDirs };
             cargoCache.set(startDir, result);
             return result;
         }
@@ -389,17 +445,30 @@ function resolveRustModulePath(dir, segments) {
 function resolveRustImport(importPath, fromFile, projectRoot) {
     const fromDir = path.dirname(fromFile);
 
-    // crate:: paths - resolve from the crate's src/ directory
+    // crate:: paths - resolve from the crate's src/ directory, or from a
+    // manifest-declared target root (fix #260b): a `[[bin]] path =
+    // "crates/core/main.rs"` roots the module tree at crates/core — the
+    // importing file's crate root dir is the DEEPEST declared target dir
+    // that is an ancestor of the file (module files live under their crate
+    // root; integration tests are separate crates and can't use crate::).
     if (importPath.startsWith('crate::')) {
         const cargo = findCargoRoot(fromDir);
         if (!cargo) return null;
 
         const rest = importPath.slice('crate::'.length);
         const segments = rest.split('::');
-        // `use crate::ITEM` where ITEM is declared in the crate root file has
-        // no ITEM.rs — the import points at lib.rs/main.rs itself.
-        return resolveRustModulePath(cargo.srcDir, segments) ||
-            rustModuleOwnFile(cargo.srcDir, fromFile);
+        const candidates = [cargo.srcDir, ...(cargo.targetDirs || [])]
+            .filter(d => fromDir === d || fromDir.startsWith(d + path.sep))
+            .sort((a, b) => b.length - a.length);
+        if (candidates.length === 0) candidates.push(cargo.srcDir);
+        for (const cand of candidates) {
+            // `use crate::ITEM` where ITEM is declared in the crate root file
+            // has no ITEM.rs — the import points at lib.rs/main.rs itself.
+            const hit = resolveRustModulePath(cand, segments) ||
+                rustModuleOwnFile(cand, fromFile);
+            if (hit) return hit;
+        }
+        return null;
     }
 
     // Own-package-name paths (fix #246): integration tests, benches, and
@@ -424,6 +493,28 @@ function resolveRustImport(importPath, fromFile, projectRoot) {
                 if (fallback) return fallback;
             }
         }
+        // Cross-crate WORKSPACE imports (fix #258, clap-measured): a sibling
+        // workspace member's [package] name resolves into that crate's source
+        // tree (`use clap::Command` from clap_bench/, ripgrep's grep-* crates
+        // importing each other). Own-package and 2015-edition child-module
+        // cases are handled above; a name matching this crate's own package
+        // inside src/ never reaches here as a workspace lookup.
+        if (firstSeg && (!cargo || firstSeg !== cargo.packageName)) {
+            // A local child module of the same name wins over a workspace
+            // crate (mod declarations resolve in the plain branch below).
+            const localChild = fs.existsSync(path.join(fromDir, firstSeg + '.rs')) ||
+                fs.existsSync(path.join(fromDir, firstSeg, 'mod.rs'));
+            if (!localChild) {
+                const registry = workspaceCrateRegistry(projectRoot);
+                const member = registry.get(firstSeg);
+                if (member && (!cargo || member.root !== cargo.root)) {
+                    const restSegs = importPath.split('::').slice(1);
+                    const resolved = restSegs.length > 0 ? resolveRustModulePath(member.srcDir, restSegs) : null;
+                    const fallback = resolved || rustModuleOwnFile(member.srcDir, fromFile);
+                    if (fallback) return fallback;
+                }
+            }
+        }
     }
 
     // super:: paths - resolve relative to parent module
@@ -819,5 +910,6 @@ module.exports = {
     extractExports,
     resolveImport,
     resolveFilePath,
+    resolveRustImport,
     findGoModule
 };

package/core/project.js

@@ -79,6 +79,7 @@ class ProjectIndex {
             this._opContentCache = new Map();
             this._opUsagesCache = new Map();
             this._opCallsCountCache = new Map();
+            this._opUsageTotalsCache = new Map();
             this._opEnclosingFnCache = new Map();
             this._opTreeCache = new Map();
             this._opLinesCache = new Map();
@@ -94,6 +95,7 @@ class ProjectIndex {
             this._opContentCache = null;
             this._opUsagesCache = null;
             this._opCallsCountCache = null;
+            this._opUsageTotalsCache = null;
             this._opEnclosingFnCache = null;
             this._opTreeCache = null;
             this._opLinesCache = null;
@@ -314,7 +316,7 @@ class ProjectIndex {
         const disableParallel = workersSetting === 0 || envWorkers === 0;
         let usedParallel = false;
 
-        if (!disableParallel && files.length > 500) {
+        if (!disableParallel && files.length > 150) {
             try {
                 const { parallelBuild } = require('./parallel-build');
                 const result = parallelBuild(this, files, {
@@ -482,7 +484,13 @@ class ProjectIndex {
             // the bare name for the whole file).
             importBindings: imports.flatMap(i => (i.names || [])
                 .filter(n => n && n !== '*' && n !== '_' && n !== '.')
-                .map(n => ({ name: n, module: i.module }))),
+                .map(n => {
+                    // Rename pairing (fix #269): `{ validate: validateSchema }
+                    // = require('./validation')` — the record's local alias
+                    // pins to ITS module, not any module exporting the name.
+                    const rn = (i.renames || []).find(r => r.original === n);
+                    return { name: n, module: i.module, ...(rn && { alias: rn.local }) };
+                })),
             exports: exports.map(e => e.name),
             exportDetails: exports,
             symbols: [],
@@ -541,15 +549,22 @@ class ProjectIndex {
                 // members) — external-contract detection needs the NAME, not
                 // just the traitImpl flag (fix #210).
                 ...(item.traitName && { traitName: item.traitName }),
-                ...(item.isSignature && { isSignature: true })
+                ...(item.isSignature && { isSignature: true }),
+                ...(item.memberAssigned && { memberAssigned: true })
             };
             fileEntry.symbols.push(symbol);
-            fileEntry.bindings.push({
-                id: symbol.bindingId,
-                name: symbol.name,
-                type: symbol.type,
-                startLine: symbol.startLine
-            });
+            // Property-assignment defs (fix #269: Reply.prototype.serialize
+            // = function) declare no lexical name — a bare reference in the
+            // file can never bind them, so they never enter the bindings
+            // table (the symbol stays indexed and method-reachable).
+            if (!item.memberAssigned) {
+                fileEntry.bindings.push({
+                    id: symbol.bindingId,
+                    name: symbol.name,
+                    type: symbol.type,
+                    startLine: symbol.startLine
+                });
+            }
 
             if (!this.symbols.has(item.name)) {
                 this.symbols.set(item.name, []);
@@ -1158,6 +1173,17 @@ class ProjectIndex {
             if (!this.calleeIndex) this.buildCalleeIndex();
             const hasFilters = options.exclude && options.exclude.length > 0;
 
+            // Per-operation memo of the whole fast-path result: the callee
+            // tiebreaker (findCallees priority 6) and reachability BFS ask
+            // for the same (name, defFile) totals thousands of times per
+            // walk. Result objects are read-only by contract.
+            const memoKey = !hasFilters && this._opUsageTotalsCache
+                ? `${name}\0${defFile}` : null;
+            if (memoKey) {
+                const hit = this._opUsageTotalsCache.get(memoKey);
+                if (hit) return hit;
+            }
+
             // Pre-compute which files can reference THIS specific definition
             const importersSet = this.exportGraph.get(defFile) || new Set();
             const defEntry = this.files.get(defFile);
@@ -1231,11 +1257,15 @@ class ProjectIndex {
                     imports++;
                 }
             }
-            // Same-package: files in same directory don't need imports to reference symbols
+            // Same-package: files in same directory don't need imports to
+            // reference symbols. dirToFiles is canonical-ordered — same
+            // iteration order as the full index scan it replaces.
             if (isDirectoryScope) {
                 const pkgDir = defDir;
-                for (const [fp, fe] of this.files) {
-                    if (fp === defFile || !fp.endsWith('.go') || path.dirname(fp) !== pkgDir) continue;
+                for (const fp of this.dirToFiles?.get(pkgDir) || []) {
+                    if (fp === defFile || !fp.endsWith('.go')) continue;
+                    const fe = this.files.get(fp);
+                    if (!fe) continue;
                     if (hasFilters && !this.matchesFilters(fe.relativePath, { exclude: options.exclude })) continue;
                     // Check if already counted as importer
                     if (importersSet.has(fp)) continue;
@@ -1252,7 +1282,9 @@ class ProjectIndex {
             }
 
             const total = calls + definitions + imports;
-            return { total, calls, definitions, imports, references: 0 };
+            const result = { total, calls, definitions, imports, references: 0 };
+            if (memoKey) this._opUsageTotalsCache.set(memoKey, result);
+            return result;
         }
 
         // Detailed path: full AST-based counting (original algorithm)