@diffci.com/diffci 0.1.11 → 0.2.0

package/node_modules/@diffci.com/core/src/planner/test-command.ts

@@ -133,6 +133,17 @@ export function planSelectiveTestCommands(
 ): SelectiveTestCommandPlan {
   const blockers = profile.adapterBlockers ?? profile.adapters?.flatMap((adapter) => adapter.blockers) ?? [];
   if (blockers.length) return { commands: [], groups: [], unroutedPaths: [...selectedPaths], refusalReason: blockers.join("; ") };
+  if (profile.vueScope) {
+    const scope = profile.vueScope;
+    const known = new Set(profile.testFilePaths);
+    const unclaimed = selectedPaths.filter(path => !known.has(path));
+    if (unclaimed.length || profile.packageManager !== "pnpm") return { commands: [], groups: [], unroutedPaths: [...unclaimed], refusalReason: "Scoped Vitest execution requires pnpm and verified package test paths" };
+    if (!selectedPaths.length) return { commands: [], groups: [], unroutedPaths: [] };
+    const paths = [...selectedPaths].sort();
+    const local = paths.map(path => scope.packageRoot === "." ? path : path.slice(scope.packageRoot.length + 1));
+    const commandSpec: CommandSpec = { executable: "pnpm", args: ["--dir", scope.packageRoot, "exec", "vitest", "run", "--config", scope.testConfig, ...local] };
+    return { commands: [commandSpec], groups: [{ runnerId: `vitest:${scope.packageRoot}/${scope.testConfig}`, label: "Declared Vue package suite", paths, commandSpec }], unroutedPaths: [] };
+  }
   const goPaths = selectedPaths.filter((path) => path.endsWith(".go"));
   if (goPaths.length) {
     const packages = profile.goTestPackages ?? {};
@@ -151,6 +162,23 @@ export function planSelectiveTestCommands(
     const group: SelectiveTestCommandGroup = { runnerId: "go:test", label: "Go package tests", paths: [...goPaths].sort(), commandSpec };
     return { commands: [...jsPlan.commands, commandSpec], groups: [...jsPlan.groups, group], unroutedPaths: [] };
   }
+  const javaPaths = selectedPaths.filter((path) => path.endsWith(".java") || path.endsWith(".kt"));
+  if (javaPaths.length) {
+    const modules = profile.mavenTestModules ?? {};
+    const unclaimed = javaPaths.filter((path) => !Object.hasOwn(modules, path));
+    if (unclaimed.length) return { commands: [], groups: [], unroutedPaths: unclaimed, refusalReason: "Maven test files require verified reactor module metadata" };
+    if (selectedPaths.some((path) => !path.endsWith(".java") && !path.endsWith(".kt"))) return { commands: [], groups: [], unroutedPaths: [...selectedPaths], refusalReason: "Mixed Maven/JavaScript selective execution requires separate CI jobs" };
+    const targets = [...new Set(javaPaths.map((path) => modules[path]!))].sort();
+    if (targets.some((target) => target !== "." && (target.startsWith("/") || target.split("/").includes("..") || /[\\\r\n]/.test(target)))) {
+      return { commands: [], groups: [], unroutedPaths: javaPaths, refusalReason: "Invalid Maven reactor module target" };
+    }
+    const maven = profile.diffciConfig?.maven;
+    const goal = maven?.goal ?? "test";
+    const args = [...(targets.length === 1 && targets[0] === "." ? [] : ["-pl", targets.join(","), "-am"]), goal, ...(maven?.profiles?.length ? ["-P", maven.profiles.join(",")] : [])];
+    const commandSpec: CommandSpec = { executable: "mvn", args };
+    const group: SelectiveTestCommandGroup = { runnerId: "maven:surefire", label: "Maven reactor tests", paths: [...javaPaths].sort(), commandSpec };
+    return { commands: [commandSpec], groups: [group], unroutedPaths: [] };
+  }
   const paths = [...selectedPaths].sort();
   if (paths.length === 0) return { commands: [], groups: [], unroutedPaths: [] };
 

package/node_modules/@diffci.com/core/src/repo/adapters/go.ts

@@ -14,6 +14,7 @@ interface GoPackage {
   DepsErrors?: unknown[];
   Incomplete?: boolean;
   GoFiles?: string[];
+  IgnoredGoFiles?: string[];
   CgoFiles?: string[];
   TestGoFiles?: string[];
   XTestGoFiles?: string[];
@@ -59,6 +60,11 @@ function internalPath(root: string, path: string): string | undefined {
   return rel === ".." || rel.startsWith("../") || isAbsolute(rel) ? undefined : rel;
 }
 
+/** go ./... excludes these names; edits still require full CI (for example testdata reads). */
+export function isGoDiscoveryIgnoredPath(path: string): boolean {
+  return path.split("/").some(part => part === "testdata" || part.startsWith("_") || part.startsWith("."));
+}
+
 export function analyzeGoMetadata(context: AdapterContext, output: string): AdapterContribution {
   const result = contribution(goAdapter);
   const all = parseGoList(output);
@@ -68,7 +74,10 @@ export function analyzeGoMetadata(context: AdapterContext, output: string): Adap
   const anchors = new Map<string, string>();
   const members = new Map<string, string[]>();
   for (const pkg of packages) {
-    const files = [...(pkg.GoFiles ?? []), ...(pkg.CgoFiles ?? []), ...(pkg.TestGoFiles ?? []), ...(pkg.XTestGoFiles ?? [])];
+    // Associate inactive files with their package conservatively. They are not runnable
+    // tests, but edits (including build constraints) must still select that package and
+    // its dependents. Unaccounted files remain a global blocker below.
+    const files = [...(pkg.GoFiles ?? []), ...(pkg.CgoFiles ?? []), ...(pkg.TestGoFiles ?? []), ...(pkg.XTestGoFiles ?? []), ...(pkg.IgnoredGoFiles ?? [])];
     const paths = files.map((file) => internalPath(context.repoPath, resolve(pkg.Dir, file)));
     if (paths.some((p) => p === undefined)) { result.blockers.push("Go package contains files outside the repository"); continue; }
     const sources = paths as string[];
@@ -110,16 +119,19 @@ export function analyzeGoMetadata(context: AdapterContext, output: string): Adap
   if (!result.sourcePaths.length) result.blockers.push("Go analysis found no local packages");
   // Ignored files/build tags, generation and testdata can change the runnable universe.
   const modeled = new Set([...result.sourcePaths, ...result.assetPaths]);
-  if (context.files.some((file) => file.endsWith(".go") && !modeled.has(file))) result.blockers.push("Go files outside the active build context require full validation");
+  const unmodeled = context.files.filter(file => file.endsWith(".go") && !modeled.has(file) && !isGoDiscoveryIgnoredPath(file));
+  if (unmodeled.length) result.blockers.push(`Go files outside the active build context require full validation: ${unmodeled.slice(0, 20).join(", ")}`);
   return result;
 }
 
 export const goAdapter: RepositoryAdapter = {
-  id: "go", version: "1", kind: "language",
+  id: "go", version: "3", kind: "language",
   detect: ({ files }) => files.some((file) => file === "go.mod" || file.endsWith(".go")),
   analyze(context) {
     const failure = contribution(this);
-    if (!context.files.includes("go.mod") || context.files.some((f) => f === "go.work" || f.endsWith("/go.mod"))) {
+    const nestedRoots = context.files.filter(f => f.endsWith("/go.mod")).map(f => f.slice(0, -"go.mod".length));
+    const scoped = context.profile.diffciConfig?.go?.scope === "root-module";
+    if (!context.files.includes("go.mod") || context.files.includes("go.work") || (nestedRoots.length && !scoped)) {
       failure.blockers.push("Go support requires one root go.mod; workspaces and nested modules require full validation");
       return failure;
     }
@@ -140,7 +152,14 @@ export const goAdapter: RepositoryAdapter = {
         env,
         stdio: ["ignore", "pipe", "pipe"],
       });
-      const result = analyzeGoMetadata(context, output);
+      const excluded = (file: string) => nestedRoots.some(root => file.startsWith(root));
+      const scopedContext = scoped ? { ...context, files: context.files.filter(file => !excluded(file)) } : context;
+      const result = analyzeGoMetadata(scopedContext, output);
+      if (scoped) {
+        context.profile.goExcludedModuleRoots = nestedRoots;
+        // A local replacement can make an excluded module part of the root module's build.
+        if (parseGoList(output).some(pkg => pkg.Module?.Replace?.Dir)) result.blockers.push("Go root-module scope with local replacements requires full validation");
+      }
       result.executionEnv = { GOOS: buildEnv.GOOS, GOARCH: buildEnv.GOARCH, CGO_ENABLED: buildEnv.CGO_ENABLED, GOFLAGS: "" };
       return result;
     } catch {

package/node_modules/@diffci.com/core/src/repo/adapters/index.ts

@@ -1,10 +1,11 @@
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { goAdapter } from "./go.js";
+import { mavenAdapter } from "./maven.js";
 import { vueAdapter } from "./vue.js";
 import type { RepositoryAdapter } from "./types.js";
 
-export const REPOSITORY_ADAPTERS: readonly RepositoryAdapter[] = [vueAdapter, goAdapter];
+export const REPOSITORY_ADAPTERS: readonly RepositoryAdapter[] = [vueAdapter, goAdapter, mavenAdapter];
 
 /** Never follows symlinks or scans dependency/build output directories. */
 export function adapterFiles(root: string, exclusions: readonly string[] = []): string[] {

package/node_modules/@diffci.com/core/src/repo/adapters/maven.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from "node:fs";
+import { dirname, posix } from "node:path";
+import { contribution, type AdapterContext, type AdapterContribution, type RepositoryAdapter } from "./types.js";
+
+interface Pom { path:string; dir:string; groupId?:string; artifactId?:string; modules:string[]; dependencies:Array<{groupId:string;artifactId:string}>; }
+
+function tags(xml:string, name:string): string[] {
+  const re=new RegExp(`<${name}\\b[^>]*>([\\s\\S]*?)<\\/${name}>`,"g"); const out:string[]=[]; let m:RegExpExecArray|null;
+  while((m=re.exec(xml))) out.push((m[1]??"").trim()); return out;
+}
+function first(xml:string,name:string):string|undefined { return tags(xml,name)[0]; }
+function parsePom(path:string, xml:string):Pom {
+  const dir=posix.dirname(path)==="."?"":posix.dirname(path);
+  const parent=first(xml,"parent")??"";
+  const own=xml.replace(/<parent\b[^>]*>[\s\S]*?<\/parent>/,"");
+  const deps=tags(xml,"dependency").map(x=>({groupId:first(x,"groupId")??"",artifactId:first(x,"artifactId")??""})).filter(x=>x.artifactId);
+  return {path,dir,groupId:first(own,"groupId")??first(parent,"groupId"),artifactId:first(own,"artifactId"),modules:tags(first(xml,"modules")??"","module"),dependencies:deps};
+}
+function under(dir:string,path:string){return !dir||path===dir||path.startsWith(dir+"/");}
+function owningPom(poms:Pom[], file:string):Pom|undefined { return poms.filter(p=>under(p.dir,file)).sort((a,b)=>b.dir.length-a.dir.length)[0]; }
+function javaFiles(context:AdapterContext, poms:Pom[], pom:Pom){return context.files.filter(f=>owningPom(poms,f)===pom&&/\/src\/(?:main|test)\/(?:java|kotlin)\/.*\.(?:java|kt)$/.test("/"+f));}
+function isTest(path:string){return /\/src\/test\/(?:java|kotlin)\//.test("/"+path)&&/(?:Test|Tests|TestCase|IT)\.(?:java|kt)$/.test(path);}
+
+export function analyzeMaven(context:AdapterContext):AdapterContribution {
+  const r=contribution(mavenAdapter);
+  const poms=context.files.filter(f=>f==="pom.xml"||f.endsWith("/pom.xml")).map(path=>parsePom(path,readFileSync(context.repoPath+"/"+path,"utf8")));
+  if(!poms.length){r.blockers.push("Maven analysis found no pom.xml");return r;}
+  const byGA=new Map(poms.filter(p=>p.artifactId).map(p=>[`${p.groupId??""}:${p.artifactId}`,p]));
+  const byArtifact=new Map(poms.filter(p=>p.artifactId).map(p=>[p.artifactId!,p]));
+  const members=new Map<Pom,string[]>(), anchors=new Map<Pom,string>();
+  for(const p of poms){const files=javaFiles(context,poms,p); if(!files.length) continue; members.set(p,files); anchors.set(p,files[0]!); r.sourcePaths.push(...files); for(const f of files) if(isTest(f)){r.testFiles.push(f);r.testPackages[f]=p.dir||".";}}
+  for(const [p,files] of members){const a=anchors.get(p)!; for(const f of files) if(f!==a) r.edges.push({from:a,to:f,kind:"import"},{from:f,to:a,kind:"import"});
+    for(const d of p.dependencies){const normalizedGroup=d.groupId.replace(/\$\{project\.groupId\}/g,p.groupId??"").replace(/\$\{pom\.groupId\}/g,p.groupId??""); const target=byGA.get(`${normalizedGroup}:${d.artifactId}`)??byArtifact.get(d.artifactId); const ta=target&&anchors.get(target); if(ta&&ta!==a) r.edges.push({from:a,to:ta,kind:"import"});}
+  }
+  if(!r.sourcePaths.length) r.blockers.push("Maven reactor contains no Java sources");
+  return r;
+}
+export const mavenAdapter:RepositoryAdapter={id:"maven",version:"1",kind:"language",detect:({files})=>files.includes("pom.xml")&&files.some(f=>f.endsWith(".java")||f.endsWith(".kt")),analyze:analyzeMaven};

package/node_modules/@diffci.com/core/src/repo/adapters/types.ts

@@ -5,6 +5,9 @@ export interface AdapterContext {
   repoPath: string;
   files: readonly string[];
   profile: RepositoryProfile;
+  vueComponentPaths?: readonly string[];
+  recordVueRead?: (path: string) => void;
+  vueAnalysisSession?: object;
 }
 
 export interface AdapterContribution {
@@ -20,6 +23,8 @@ export interface AdapterContribution {
   executionEnv?: Record<string, string>;
   /** Global blockers: missing edges cannot be dismissed using graph reachability. */
   blockers: string[];
+  fileBlockers?: Array<{ path: string; reason: string }>;
+  performance?: { phasesMs: Record<string, number>; counts: Record<string, number> };
 }
 
 export interface RepositoryAdapter {

package/node_modules/@diffci.com/core/src/repo/adapters/vue.ts

@@ -1,23 +1,101 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { compileScript, compileTemplate, parse } from "@vue/compiler-sfc";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { createRequire } from "node:module";
+import ts from "typescript";
+const loadCompiler = createRequire(import.meta.url);
+let previousSession: object | undefined;
+const compilerConfigs = new Set<string>();
+
+/** Only direct imports registered in a literal component options object are provable. */
+function registeredComponents(source: string): Set<string> {
+  const file = ts.createSourceFile("component.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const imports = new Set<string>();
+  const factories = new Set<string>();
+  for (const statement of file.statements) {
+    if (!ts.isImportDeclaration(statement) || statement.importClause?.isTypeOnly) continue;
+    const clause = statement.importClause;
+    if (clause?.name) imports.add(clause.name.text);
+    if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const binding of clause.namedBindings.elements) {
+        if (binding.isTypeOnly) continue;
+        imports.add(binding.name.text);
+        if (ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "vue" && (binding.propertyName ?? binding.name).text === "defineComponent") factories.add(binding.name.text);
+      }
+    }
+  }
+  const names = new Set<string>();
+  const exp = file.statements.find(ts.isExportAssignment);
+  if (!exp || exp.isExportEquals) return names;
+  let value = exp.expression;
+  if (ts.isCallExpression(value) && ts.isIdentifier(value.expression) && factories.has(value.expression.text) && value.arguments.length === 1) value = value.arguments[0];
+  if (!ts.isObjectLiteralExpression(value) || value.properties.some(p => ts.isSpreadAssignment(p) || (p.name && ts.isComputedPropertyName(p.name)))) return names;
+  const registrations = value.properties.filter(p => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === "components");
+  if (registrations.length !== 1 || !ts.isPropertyAssignment(registrations[0]) || !ts.isObjectLiteralExpression(registrations[0].initializer)) return names;
+  for (const property of registrations[0].initializer.properties) {
+    if (ts.isShorthandPropertyAssignment(property) && imports.has(property.name.text)) names.add(property.name.text);
+    else if (ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) && ts.isIdentifier(property.initializer) && imports.has(property.initializer.text)) names.add(property.name.text);
+    else return new Set();
+  }
+  return new Set([...names].flatMap(name => [name, name.replace(/\B([A-Z])/g, "-$1").toLowerCase()]));
+}
 import { contribution, type RepositoryAdapter } from "./types.js";
 
 /** Explicit Vue SFC imports. Runtime component registries and preprocessors require full CI. */
 export const vueAdapter: RepositoryAdapter = {
-  id: "vue", version: "1", kind: "framework",
+  id: "vue", version: "7", kind: "framework",
   detect: ({ files }) => files.some((file) => file.endsWith(".vue")),
   analyze(context) {
+    const phasesMs: Record<string, number> = {};
+    const counts: Record<string, number> = { components: 0, typeReads: 0, registrationScans: 0 };
+    const measure = <T>(name: string, work: () => T): T => {
+      const start = performance.now();
+      try { return work(); } finally { phasesMs[name] = (phasesMs[name] ?? 0) + performance.now() - start; }
+    };
+    // Go and scoped TS-only packages do not need to initialize Vue's compiler/Babel
+    // dependency tree. Keep the same synchronous adapter contract, loading it on use.
+    const { compileScript, compileTemplate, invalidateTypeCache, parse, registerTS } = measure("compilerLoad", () => loadCompiler("@vue/compiler-sfc")) as typeof import("@vue/compiler-sfc");
+    registerTS(() => ts);
+    const session = context.vueAnalysisSession ?? {};
+    if (session !== previousSession) {
+      for (const file of compilerConfigs) invalidateTypeCache(file);
+      compilerConfigs.clear();
+      previousSession = session;
+    }
+    const recordRead = (file: string) => {
+      if (file.endsWith(".json")) compilerConfigs.add(file);
+      context.recordVueRead?.(file);
+    };
     const result = contribution(this);
+    result.performance = { phasesMs, counts };
     const dependencies = [...context.profile.packageJson.dependencies, ...context.profile.packageJson.devDependencies];
     if (dependencies.includes("nuxt") || context.files.some((file) => /(?:^|\/)nuxt\.config\./.test(file))) {
       result.blockers.push("Nuxt implicit routes and auto-imports require a dedicated framework adapter");
     }
-    for (const path of context.files.filter((file) => file.endsWith(".vue"))) {
+    for (const path of context.vueComponentPaths ?? context.files.filter((file) => file.endsWith(".vue"))) {
+      counts.components++;
       result.sourcePaths.push(path);
-      const block = (reason: string) => result.blockers.push(`Vue ${path}: ${reason}`);
+      const block = (reason: string) => {
+        const message = `Vue ${path}: ${reason}`;
+        result.blockers.push(message);
+        (result.fileBlockers ??= []).push({ path, reason: message });
+      };
+      const typeDependencies = new Set<string>();
+      const recordTypeDependency = (file: string) => {
+        recordRead(file);
+        const dependency = relative(context.repoPath, resolve(file)).replace(/\\/g, "/");
+        if (dependency === ".." || dependency.startsWith("../") || isAbsolute(dependency)) throw new Error("Vue type dependency escapes repository");
+        typeDependencies.add(dependency);
+      };
       try {
-        const { descriptor, errors } = parse(readFileSync(join(context.repoPath, path), "utf8"), { filename: path });
+        const raw = measure("sourceRead", () => readFileSync(join(context.repoPath, path), "utf8"));
+        // compiler-sfc discards an empty script block then reports a missing block.
+        // Recognize only this exact dependency-free SFC shape, not arbitrary parse errors.
+        if (/^\s*<script(?:\s+setup)?(?:\s+lang=["'](?:ts|js)["'])?\s*>\s*<\/script>\s*$/.test(raw)) {
+          result.virtualSources.push({ path, source: "export default {};" });
+          continue;
+        }
+        // Dependency extraction uses code, bindings and errors, never source maps.
+        const { descriptor, errors } = measure("sfcParse", () => parse(raw, { filename: join(context.repoPath, path), sourceMap: false }));
         if (errors.length) block("component parse failed");
         if (descriptor.customBlocks.length) block("custom blocks require a framework plugin");
         const blocks = [descriptor.script, descriptor.scriptSetup, descriptor.template, ...descriptor.styles].filter((b) => b !== null);
@@ -26,17 +104,39 @@ export const vueAdapter: RepositoryAdapter = {
           if (b.lang && !["js", "ts", "jsx", "tsx", "html", "css"].includes(b.lang)) block(`unsupported preprocessor ${b.lang}`);
         }
         const script = descriptor.script || descriptor.scriptSetup
-          ? compileScript(descriptor, { id: path }) : undefined;
+          ? measure("scriptCompile", () => compileScript(descriptor, { id: path, sourceMap: false, fs: {
+            fileExists(file) { recordRead(file); return ts.sys.fileExists(file); },
+            readFile(file) {
+              recordRead(file);
+              recordTypeDependency(file);
+              counts.typeReads++;
+              return readFileSync(file, "utf8");
+            },
+          } })) : undefined;
+        for (const dependency of script?.deps ?? []) recordTypeDependency(dependency);
+        // Imported macro types affect generated runtime props. Retain the files read
+        // by the compiler even when the generated script erases their imports.
+        for (const dependency of typeDependencies) {
+          if (/\.[cm]?[jt]sx?$/.test(dependency)) result.sourcePaths.push(dependency);
+          else result.assetPaths.push(dependency);
+          result.edges.push({ from: path, to: dependency, kind: "asset" });
+        }
         let source = script?.content ?? "";
         if (/\bimport\.meta\.glob(?:Eager)?\s*\(/.test(source)) block("glob imports require bundler dependency expansion");
         if (descriptor.template && !descriptor.template.src && !descriptor.template.lang) {
-          const template = compileTemplate({
-            source: descriptor.template.content, filename: path, id: path,
-            compilerOptions: { bindingMetadata: script?.bindings },
-          });
+          const templateBlock = descriptor.template;
+          const template = measure("templateCompile", () => compileTemplate({
+            source: templateBlock.content, filename: path, id: path,
+            compilerOptions: { bindingMetadata: script?.bindings, sourceMap: false },
+          }));
           if (template.errors.length) block("template compilation failed");
           // These calls represent dependencies supplied at runtime, outside the import graph.
-          if (/\b_resolve(?:DynamicComponent|Component|Directive)\s*\(/.test(template.code)) block("runtime component/directive resolution requires full validation");
+          const componentCalls = [...template.code.matchAll(/\b_resolveComponent\s*\(\s*(["'])(.*?)\1/g)];
+          // Script-setup bindings and native-only templates have no runtime
+          // component calls, so an Options API registration scan cannot help.
+          const registrations = componentCalls.length ? measure("registrationScan", () => { counts.registrationScans++; return registeredComponents(source); }) : new Set<string>();
+          const unresolved = componentCalls.some(match => !registrations.has(match[2]));
+          if (unresolved || /\b_resolve(?:DynamicComponent|Directive)\s*\(/.test(template.code)) block("runtime component/directive resolution requires full validation");
           source += `\n${template.code}`;
         } else if (descriptor.template) block("external or preprocessed template requires full validation");
         for (const style of descriptor.styles) {
@@ -44,8 +144,13 @@ export const vueAdapter: RepositoryAdapter = {
           if (/@import\b|url\s*\(/i.test(style.content)) block("style imports or URLs require full validation");
         }
         result.virtualSources.push({ path, source });
-      } catch {
-        block("component could not be analyzed");
+      } catch (error) {
+        const detail = String(error instanceof Error ? error.message : error).replaceAll(context.repoPath, "<repo>").split("\n")[0].slice(0, 240);
+        block(`component could not be analyzed: ${detail}`);
+      } finally {
+        // compiler-sfc caches parsed imported types globally. Do not let a later
+        // component or a second analysis reuse stale types or bypass filesystem reads.
+        measure("typeCacheInvalidation", () => { for (const dependency of typeDependencies) invalidateTypeCache(join(context.repoPath, dependency)); });
       }
     }
     return result;