@archora/core 1.3.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archora/core",
-  "version": "1.3.0",
+  "version": "2.1.0",
   "type": "module",
   "description": "Framework-independent analyzer core for Archora. Builds the dependency model, detects cycles, computes metrics and recommendations from any FileSource. No Vue, Pinia or Tauri dependencies.",
   "author": "Archora <archora@archora.dev>",

package/src/README.md

@@ -1,4 +1,4 @@
 # core
 
-Фреймворк-независимое ядро: analyzer, graph, metrics, rules, report.
-Не импортирует Vue/Pinia/Tailwind/Tauri. Должно работать в чистом Node.
+Framework-independent core: analyzer, graph, metrics, rules, report.
+Does not import Vue/Pinia/Tailwind/Tauri. Must run in plain Node.

package/src/analyzer/__tests__/__snapshots__/referenceSnapshot.test.ts.snap

@@ -38,7 +38,7 @@ exports[`reference corpus snapshots > nuxt-server-routes: stable summary 1`] = `
 
 exports[`reference corpus snapshots > react-admin-basic: stable summary 1`] = `
 {
-  "archDebtGrade": "B",
+  "archDebtGrade": "A",
   "cycles": 0,
   "edges": 11,
   "modules": 11,

package/src/analyzer/__tests__/hotZones.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest';
+import { markBarrelModules, rankHotZones } from '../hotZones';
+import type { ModuleMetrics, ModuleNode, ParsedFileSummary } from '../types';
+
+function module(id: string, overrides: Partial<ModuleNode> = {}): ModuleNode {
+  return {
+    id,
+    absPath: `/${id}`,
+    kind: 'unknown',
+    language: 'ts',
+    loc: 1,
+    exports: [],
+    isInfra: false,
+    ...overrides,
+  };
+}
+
+function metrics(overrides: Partial<ModuleMetrics> = {}): ModuleMetrics {
+  return {
+    fanIn: 0,
+    fanOut: 0,
+    instability: 0,
+    depth: 0,
+    inCycle: false,
+    couplingScore: 0,
+    hotnessScore: 0,
+    ...overrides,
+  };
+}
+
+function summary(relPath: string, overrides: Partial<ParsedFileSummary> = {}): ParsedFileSummary {
+  return {
+    relPath,
+    language: 'ts',
+    loc: 1,
+    imports: [],
+    exports: [],
+    runtimeFacts: [],
+    frameworkFacts: [],
+    routeFacts: [],
+    stateFacts: [],
+    assetFacts: [],
+    limitations: [],
+    ...overrides,
+  };
+}
+
+describe('markBarrelModules', () => {
+  it('flags a thin index barrel with fan-out >= 3 even when no export source is enumerated', () => {
+    // Pinia `packages/pinia/src/index.ts`: fan-out 8, 66 named re-exports the
+    // parser couldn't resolve a source for, ~70 loc — thin glue.
+    const modules = [
+      module('packages/pinia/src/index.ts', {
+        loc: 70,
+        exports: Array.from({ length: 66 }, (_, i) => `reexport${i}`),
+      }),
+    ];
+    const m = { 'packages/pinia/src/index.ts': metrics({ fanOut: 8 }) };
+    markBarrelModules({
+      modules,
+      metrics: m,
+      parserFacts: [summary('packages/pinia/src/index.ts', { loc: 70 })],
+    });
+    expect(modules[0]?.isBarrel).toBe(true);
+  });
+
+  it('flags a mid/small package barrel below the old fan-out fallback', () => {
+    // VueUse `packages/math/index.ts`: fan-out 18, ~20 loc.
+    const modules = [module('packages/math/index.ts', { loc: 20 })];
+    const m = { 'packages/math/index.ts': metrics({ fanOut: 18 }) };
+    markBarrelModules({ modules, metrics: m, parserFacts: [] });
+    expect(modules[0]?.isBarrel).toBe(true);
+  });
+
+  it('does not flag a fat module with many source lines per export', () => {
+    // VueUse `useStorage/index.ts`: loc 328, surface 7 → 46 loc/item.
+    const modules = [module('packages/core/useStorage/index.ts', { loc: 328 })];
+    const m = { 'packages/core/useStorage/index.ts': metrics({ fanOut: 5 }) };
+    markBarrelModules({
+      modules,
+      metrics: m,
+      parserFacts: [summary('packages/core/useStorage/index.ts', { loc: 328 })],
+    });
+    expect(modules[0]?.isBarrel).toBeUndefined();
+  });
+
+  it('does not flag a fan-out-0 multi-export util that re-exports nothing', () => {
+    // VueUse `shared/utils/is.ts`: fan-out 0, 13 own exports — a leaf, not glue.
+    const modules = [
+      module('packages/shared/utils/is.ts', {
+        loc: 30,
+        exports: Array.from({ length: 13 }, (_, i) => `is${i}`),
+      }),
+    ];
+    const m = { 'packages/shared/utils/is.ts': metrics({ fanOut: 0 }) };
+    markBarrelModules({ modules, metrics: m, parserFacts: [] });
+    expect(modules[0]?.isBarrel).toBeUndefined();
+  });
+
+  it('does not flag a thin module whose surface is below the floor', () => {
+    // Two imports, two re-exports: not an aggregation surface.
+    const modules = [module('src/glue.ts', { loc: 3 })];
+    const m = { 'src/glue.ts': metrics({ fanOut: 3 }) };
+    markBarrelModules({ modules, metrics: m, parserFacts: [] });
+    expect(modules[0]?.isBarrel).toBeUndefined();
+  });
+});
+
+describe('rankHotZones', () => {
+  it('drops barrels from the ranked window without backfilling lower-signal modules', () => {
+    const modules = [module('barrel/index.ts', { isBarrel: true }), module('a.ts'), module('b.ts')];
+    const m = {
+      'barrel/index.ts': metrics({ hotnessScore: 5 }),
+      'a.ts': metrics({ hotnessScore: 3 }),
+      'b.ts': metrics({ hotnessScore: 1 }),
+    };
+    expect(rankHotZones({ modules, metrics: m, topN: 2 })).toEqual(['a.ts']);
+  });
+
+  it('excludes infra modules', () => {
+    const modules = [module('infra.ts', { isInfra: true }), module('app.ts')];
+    const m = {
+      'infra.ts': metrics({ hotnessScore: 9 }),
+      'app.ts': metrics({ hotnessScore: 2 }),
+    };
+    expect(rankHotZones({ modules, metrics: m })).toEqual(['app.ts']);
+  });
+});

package/src/analyzer/__tests__/memoryRisk.test.ts

@@ -111,6 +111,100 @@ describe('memory risk analysis', () => {
     ]);
   });
 
+  it('does not flag a bare fire-and-forget setTimeout', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              setTimeout(() => window.removeEventListener('x', () => {}), 100);
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect((result.memoryRisks ?? []).filter((risk) => risk.kind === 'timer-cleanup')).toEqual([]);
+  });
+
+  it('flags a captured setTimeout handle without clearTimeout', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              const id = setTimeout(() => {}, 100);
+              return undefined;
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks).toEqual([
+      expect.objectContaining({
+        kind: 'timer-cleanup',
+        moduleId: 'src/App.tsx',
+        framework: 'react',
+      }),
+    ]);
+  });
+
+  it('keeps a captured setTimeout with clearTimeout clean', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              const id = setTimeout(() => {}, 100);
+              return () => clearTimeout(id);
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect((result.memoryRisks ?? []).filter((risk) => risk.kind === 'timer-cleanup')).toEqual([]);
+  });
+
+  it('still flags setInterval without clearInterval', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              setInterval(() => {}, 1000);
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks).toEqual([
+      expect.objectContaining({ kind: 'timer-cleanup', moduleId: 'src/App.tsx' }),
+    ]);
+  });
+
   it('does not flag Next server modules as browser memory risks', async () => {
     const result = await analyze(
       createInMemoryFileSource('/p', {

package/src/analyzer/__tests__/recommendations.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { computeRecommendations } from '../recommendations';
 import type { Cycle, DependencyEdge, ModuleMetrics, ModuleNode } from '../types';
+import type { TemporalCoupling } from '../../git/types';
 
 function module(id: string, overrides: Partial<ModuleNode> = {}): ModuleNode {
   return {
@@ -168,4 +169,70 @@ describe('computeRecommendations', () => {
     const r = recs.find((x) => x.kind === 'unused-utility')!;
     expect(r.params.name).toBe('dead.ts');
   });
+
+  it('only surfaces hidden cross-boundary temporal couplings, ranked, capped at 10', () => {
+    function coupling(
+      a: string,
+      b: string,
+      hidden: boolean,
+      crossBoundary: boolean,
+      risk: number,
+    ): TemporalCoupling {
+      return {
+        a,
+        b,
+        coOccurrences: 5,
+        scoreA: 0.8,
+        scoreB: 0.8,
+        score: 0.8,
+        hidden,
+        crossBoundary,
+        risk,
+      };
+    }
+    const temporalCoupling: TemporalCoupling[] = [
+      coupling('features/a.ts', 'entities/b.ts', true, true, 0.9),
+      coupling('features/c.ts', 'shared/d.ts', true, true, 0.7),
+      coupling('shared/x.ts', 'shared/y.ts', true, false, 0.95), // same group: dropped
+      coupling('features/e.ts', 'entities/f.ts', false, true, 0.95), // visible: dropped
+    ];
+    const recs = computeRecommendations({
+      modules: [],
+      edges: [],
+      metrics: {},
+      cycles: [],
+      layerViolations: [],
+      hotZones: [],
+      temporalCoupling,
+    });
+    const temporal = recs.filter((r) => r.kind === 'temporal-coupling');
+    expect(temporal).toHaveLength(2);
+    // Input order is risk-sorted by the detector and preserved.
+    expect(temporal[0]!.modules).toEqual(['features/a.ts', 'entities/b.ts']);
+    expect(temporal[1]!.modules).toEqual(['features/c.ts', 'shared/d.ts']);
+  });
+
+  it('caps temporal-coupling recommendations at 10', () => {
+    const temporalCoupling: TemporalCoupling[] = Array.from({ length: 15 }, (_, i) => ({
+      a: `features/a${i}.ts`,
+      b: `entities/b${i}.ts`,
+      coOccurrences: 5,
+      scoreA: 0.8,
+      scoreB: 0.8,
+      score: 0.8,
+      hidden: true,
+      crossBoundary: true,
+      risk: 1 - i * 0.01,
+    }));
+    const recs = computeRecommendations({
+      modules: [],
+      edges: [],
+      metrics: {},
+      cycles: [],
+      layerViolations: [],
+      hotZones: [],
+      temporalCoupling,
+    });
+    expect(recs.filter((r) => r.kind === 'temporal-coupling')).toHaveLength(10);
+  });
 });

package/src/analyzer/__tests__/resolve.test.ts

@@ -14,6 +14,33 @@ describe('resolve', () => {
     expect(aliases).toEqual([{ prefix: '@', targets: ['src'] }]);
   });
 
+  it('resolves a tsconfig wildcard whose target has an interior star to the package index', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          baseUrl: '.',
+          paths: { '@x/*': ['pkgs/*/src'], '@x/legacy': ['pkgs/legacy/src'] },
+        },
+      }),
+      'pkgs/foo/src/index.ts': 'export const foo = 1;',
+      'pkgs/legacy/src/index.ts': 'export const legacy = 1;',
+      'src/main.ts': "import { foo } from '@x/foo';",
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+      tsconfigPath: 'tsconfig.json',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    // `@x/*` -> `pkgs/*/src`: the captured `foo` is substituted at the star,
+    // then directory->index resolution lands on the package index file.
+    expect(await r.resolve('@x/foo', 'src/main.ts')).toBe('pkgs/foo/src/index.ts');
+    // an exact tsconfig path (no star) shadows the wildcard for its own key.
+    expect(await r.resolve('@x/legacy', 'src/main.ts')).toBe('pkgs/legacy/src/index.ts');
+  });
+
   it('resolves @/ alias to src/*.ts and *.vue', async () => {
     const src = await createNodeFsFileSource({ rootPath: fixturePath('sample-vue-app') });
     const r = createResolver(src, { aliases: parseTsconfigPaths(await src.read('tsconfig.json')) });

package/src/analyzer/__tests__/rsc.test.ts

@@ -7,7 +7,11 @@ import { analyze } from '../index';
 import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
 import type { DependencyEdge, ModuleNode } from '../types';
 
-function mod(id: string, runtime: ModuleNode['runtime'] = 'shared'): ModuleNode {
+function mod(
+  id: string,
+  runtime: ModuleNode['runtime'] = 'shared',
+  opts: { isServerActions?: boolean } = {},
+): ModuleNode {
   return {
     id,
     absPath: id,
@@ -17,6 +21,7 @@ function mod(id: string, runtime: ModuleNode['runtime'] = 'shared'): ModuleNode
     exports: [],
     isInfra: false,
     runtime,
+    ...(opts.isServerActions ? { isServerActions: true } : {}),
   };
 }
 
@@ -118,6 +123,39 @@ describe('detectRscLeaks', () => {
     expect(leaks[0]?.edge?.to).toBe('lib/db.ts');
   });
 
+  it("does not flag a client importing a 'use server' Server Actions module", () => {
+    // The ubiquitous Next.js app-router pattern: a client component imports
+    // server actions (forms/mutations). Next compiles them into RPC references;
+    // nothing server-only ships to the browser, so this is not a leak.
+    const modules = [
+      mod('components/cart/modal.tsx', 'client'),
+      mod('components/cart/actions.ts', 'server', { isServerActions: true }),
+    ];
+    const edges = [edge('components/cart/modal.tsx', 'components/cart/actions.ts')];
+    expect(detectRscLeaks({ modules, edges })).toHaveLength(0);
+  });
+
+  it("still flags client -> server-only when the server module is not 'use server'", () => {
+    const modules = [
+      mod('app/Form.tsx', 'client'),
+      mod('lib/secret.ts', 'server'), // server via server-only / convention, no 'use server'
+    ];
+    const edges = [edge('app/Form.tsx', 'lib/secret.ts')];
+    const leaks = detectRscLeaks({ modules, edges });
+    expect(leaks).toHaveLength(1);
+    expect(leaks[0]?.edge?.to).toBe('lib/secret.ts');
+  });
+
+  it("does not flag a transitive client -> shared -> 'use server' actions chain", () => {
+    const modules = [
+      mod('app/Form.tsx', 'client'),
+      mod('lib/index.ts', 'shared'), // barrel
+      mod('lib/actions.ts', 'server', { isServerActions: true }),
+    ];
+    const edges = [edge('app/Form.tsx', 'lib/index.ts'), edge('lib/index.ts', 'lib/actions.ts')];
+    expect(detectRscLeaks({ modules, edges })).toHaveLength(0);
+  });
+
   it("flags a client component importing a module poisoned with 'server-only'", async () => {
     const fs = createInMemoryFileSource('/repo', {
       'package.json': JSON.stringify({ dependencies: { next: '^14.0.0' } }),
@@ -181,14 +219,14 @@ describe('detectRscLeaks', () => {
 });
 
 describe('rsc-leak end-to-end', () => {
-  it('surfaces client->server import as a contract violation in analyze()', async () => {
+  it('surfaces client->server-only import as a contract violation in analyze()', async () => {
     const fs = createInMemoryFileSource('/repo', {
       'package.json': JSON.stringify({ name: 'x' }),
       'app/page.tsx':
         "import { db } from '../lib/db';\nexport default function P(){ return db; }\n",
       'app/Form.tsx':
         "'use client';\nimport { db } from '../lib/db';\nexport default function F(){ return db; }\n",
-      'lib/db.ts': "'use server';\nexport const db = 1;\n",
+      'lib/db.ts': "import 'server-only';\nexport const db = 1;\n",
     });
 
     const scan = await analyze(fs);
@@ -198,4 +236,25 @@ describe('rsc-leak end-to-end', () => {
       true,
     );
   });
+
+  it("does not flag a client importing a 'use server' actions module in analyze()", async () => {
+    // Mirrors vercel/commerce: components/cart/modal.tsx ('use client') imports
+    // components/cart/actions.ts ('use server'). This must not be an rsc-leak.
+    const fs = createInMemoryFileSource('/repo', {
+      'package.json': JSON.stringify({ dependencies: { next: '^14.0.0' } }),
+      'components/cart/modal.tsx':
+        "'use client';\nimport { addItem } from './actions';\nexport default function M(){ return addItem; }\n",
+      'components/cart/actions.ts': "'use server';\nexport async function addItem(){ return 1; }\n",
+    });
+
+    const scan = await analyze(fs);
+    const leaks = scan.contractViolations.filter((v) => v.kind === 'rsc-leak');
+    expect(
+      leaks.some(
+        (l) =>
+          l.edge?.from === 'components/cart/modal.tsx' &&
+          l.edge?.to === 'components/cart/actions.ts',
+      ),
+    ).toBe(false);
+  });
 });

package/src/analyzer/buildGraph.ts

@@ -14,7 +14,7 @@ import { createParserRegistry, isParseFailure } from './parsers';
 import type { Framework } from './detect';
 import { applyAlias, type PathAlias, type Resolver } from './resolve';
 import { classifyKind, isInfra } from './classify';
-import { classifyModuleRuntime } from './rsc';
+import { classifyModuleRuntime, isServerActionsModule } from './rsc';
 import type { ArchoraConfig } from '../config/frontScopeConfig';
 
 export interface BuildGraphInput {
@@ -111,6 +111,7 @@ export async function buildGraph(input: BuildGraphInput): Promise<BuildGraphResu
       ...(p.imports.some((i) => i.specifier === 'server-only') ? { importsServerOnly: true } : {}),
       ...(p.imports.some((i) => i.specifier === 'client-only') ? { importsClientOnly: true } : {}),
     }),
+    ...(isServerActionsModule(p.directives) ? { isServerActions: true } : {}),
   }));
   const parserFacts = parsed.map((p) => toParsedFileSummary(p, input.framework ?? 'unknown'));
 

package/src/analyzer/hotZones.ts

@@ -1,4 +1,4 @@
-import type { ModuleId, ModuleMetrics, ModuleNode } from './types';
+import type { ModuleId, ModuleMetrics, ModuleNode, ParsedFileSummary } from './types';
 
 export interface RankHotZonesInput {
   modules: ModuleNode[];
@@ -13,5 +13,97 @@ export function rankHotZones(input: RankHotZonesInput): ModuleId[] {
     .map((m) => ({ id: m.id, score: metrics[m.id]?.hotnessScore ?? 0 }))
     .filter((x) => x.score > 0);
   candidates.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
-  return candidates.slice(0, topN).map((c) => c.id);
+  // Rank the full hotness window first, then drop re-export barrels from it.
+  // A barrel's high fan-out is by design, not a risk — but excluding it from the
+  // candidate pool before the cut would only backfill the window with lower-
+  // signal modules. Removing it from the top-N keeps the surfaced set focused on
+  // genuine hot zones without inventing new ones.
+  const barrels = new Set(modules.filter((m) => m.isBarrel).map((m) => m.id));
+  return candidates
+    .slice(0, topN)
+    .map((c) => c.id)
+    .filter((id) => !barrels.has(id));
+}
+
+// A barrel imports the things it re-exports, so it has a non-trivial fan-out;
+// a leaf that defines its own exports has fan-out 0. Below this floor we keep
+// the module even if it is thin (small multi-export utils re-export nothing).
+const BARREL_MIN_FANOUT = 3;
+// Barrels expose a real aggregation surface — too few pass-throughs and it is
+// just a normal module with a couple of imports.
+const BARREL_MIN_SURFACE = 5;
+// Source lines per surface item. Barrels are thin glue (≈1–2 loc per
+// re-export); real modules carry many loc per export.
+const BARREL_MAX_LOC_PER_SURFACE = 4;
+
+export interface MarkBarrelModulesInput {
+  modules: ModuleNode[];
+  metrics: Record<ModuleId, ModuleMetrics>;
+  parserFacts?: ParsedFileSummary[];
+}
+
+/**
+ * Tag re-export barrels so hot-zone ranking can skip them. Runs post-graph
+ * because barrel detection needs the fan-out metric plus the module's loc and
+ * export count. Mutates `ModuleNode.isBarrel` in place; additive, leaves every
+ * other field untouched.
+ */
+export function markBarrelModules(input: MarkBarrelModulesInput): void {
+  const { modules, metrics, parserFacts } = input;
+  const factsByModule = indexParserFacts(parserFacts);
+  for (const m of modules) {
+    if (isBarrelModule(m, metrics[m.id], factsByModule)) m.isBarrel = true;
+  }
+}
+
+/**
+ * A re-export barrel (e.g. `packages/core/index.ts` re-exporting every module)
+ * has high fan-out by design — that is its job, not a risk, and "split this
+ * module" is bad advice. Detected by THINNESS rather than a re-export ratio:
+ * the parser almost never populates `ExportFact.source` (star re-exports, and
+ * named re-exports it can't resolve), so the ratio reads 0 even for obvious
+ * barrels. A barrel instead imports the things it passes through (fan-out),
+ * exposes a wide surface, and carries very few source lines per surface item —
+ * it is thin glue, not a module with real logic.
+ */
+function isBarrelModule(
+  module: ModuleNode,
+  metrics: ModuleMetrics | undefined,
+  factsByModule: Map<string, ParsedFileSummary>,
+): boolean {
+  if (!metrics) return false;
+  const fanOut = metrics.fanOut;
+  if (fanOut < BARREL_MIN_FANOUT) return false;
+  const summary = matchParserFacts(factsByModule, module.id);
+  const ownExportCount = module.exports.length || (summary?.exports.length ?? 0);
+  const surface = Math.max(fanOut, ownExportCount);
+  if (surface < BARREL_MIN_SURFACE) return false;
+  const loc = module.loc || summary?.loc || 0;
+  return loc < surface * BARREL_MAX_LOC_PER_SURFACE;
+}
+
+function indexParserFacts(
+  parserFacts: ParsedFileSummary[] | undefined,
+): Map<string, ParsedFileSummary> {
+  const out = new Map<string, ParsedFileSummary>();
+  if (!parserFacts) return out;
+  for (const f of parserFacts) out.set(normalizeRel(f.relPath), f);
+  return out;
+}
+
+function matchParserFacts(
+  factsByModule: Map<string, ParsedFileSummary>,
+  moduleId: ModuleId,
+): ParsedFileSummary | undefined {
+  const id = normalizeRel(moduleId);
+  const direct = factsByModule.get(id);
+  if (direct) return direct;
+  for (const [rel, f] of factsByModule) {
+    if (id.endsWith(`/${rel}`) || rel.endsWith(`/${id}`)) return f;
+  }
+  return undefined;
+}
+
+function normalizeRel(p: string): string {
+  return p.replace(/^\.\//u, '');
 }

package/src/analyzer/incremental.ts

@@ -26,7 +26,7 @@ import { createResolver } from './resolve';
 import { createParserRegistry, isParseFailure } from './parsers';
 import { classifyKind, isInfra } from './classify';
 import { isNuxtComposablePath } from './buildGraph';
-import { classifyModuleRuntime, detectRscLeaks } from './rsc';
+import { classifyModuleRuntime, detectRscLeaks, isServerActionsModule } from './rsc';
 import { detectCycles } from './cycles';
 import { computeMetrics } from './metrics';
 import { rankHotZones } from './hotZones';
@@ -191,6 +191,7 @@ export async function incrementalAnalyze(input: IncrementalAnalyzeInput): Promis
           ? { importsClientOnly: true }
           : {}),
       }),
+      ...(isServerActionsModule(p.directives) ? { isServerActions: true } : {}),
     });
   }
   const updatedModuleIds = new Set(updatedModules.map((m) => m.id));

package/src/analyzer/index.ts

@@ -14,7 +14,7 @@ import { detectFramework, type Framework } from './detect';
 import { detectCycles } from './cycles';
 import { countBrokenCycles, parseEdgeKey } from './feedbackArcSet';
 import { computeMetrics } from './metrics';
-import { rankHotZones } from './hotZones';
+import { markBarrelModules, rankHotZones } from './hotZones';
 import { detectLayerViolations } from './layers';
 import { computeArchDebt } from './archDebt';
 import { computeRecommendations } from './recommendations';
@@ -181,6 +181,7 @@ export async function analyze(
     if (entries.includes(m.id) && m.kind === 'unknown') m.kind = 'entry';
   }
 
+  markBarrelModules({ modules, metrics, parserFacts });
   const hotZones = rankHotZones({ modules, metrics, topN: options.topHotZones ?? 10 });
   const layerViolations = detectLayerViolations(modules, edges, config.layerOverrides);
   const archDebt = computeArchDebt({