@archora/core 1.1.0 → 2.0.0

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 {
@@ -108,7 +108,10 @@ export async function buildGraph(input: BuildGraphInput): Promise<BuildGraphResu
       relPath: p.relPath,
       framework: input.framework ?? 'unknown',
       ...(p.directives ? { directives: p.directives } : {}),
+      ...(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'));
 
@@ -255,6 +258,33 @@ export async function buildGraph(input: BuildGraphInput): Promise<BuildGraphResu
     }
   }
 
+  // Nuxt auto-import: composables/** are exposed globally, a consumer calls
+  // useFoo() with no import. Resolve the call against a name -> composable file
+  // registry. unplugin-auto-import outside Nuxt is config-driven (see docs limitation).
+  const composableRegistry = buildComposableRegistry(parsed, framework);
+  if (composableRegistry.size > 0) {
+    for (const file of parsed) {
+      if (!file.callIdentifiers || file.callIdentifiers.length === 0) continue;
+      for (const name of file.callIdentifiers) {
+        const target = composableRegistry.get(name);
+        if (!target || target === file.relPath) continue;
+        const key = `${file.relPath}\u0001${target}`;
+        if (existingEdges.has(key)) continue;
+        existingEdges.add(key);
+        edges.push({
+          from: file.relPath,
+          to: target,
+          kind: 'auto-import',
+          specifier: name,
+          resolved: true,
+          confidence: 'medium',
+          resolutionKind: 'framework-auto',
+          approximate: true,
+        });
+      }
+    }
+  }
+
   return { modules, edges, parserFacts, warnings };
 }
 
@@ -365,6 +395,44 @@ function buildComponentRegistry(
   return registry;
 }
 
+// Nuxt auto-import: composables/**/*.{ts,js} are exposed globally. Registry name =
+// named exports + file basename (for `export default`). First-wins on collision.
+// Nuxt only: unplugin-auto-import outside Nuxt is config-driven (see docs limitation).
+const NUXT_COMPOSABLE_EXT = /\.[cm]?[jt]s$/u;
+
+// True when one of `rel`'s directory segments equals `segment`. Linear scan, used
+// instead of `(^|\/)<dir>\/.+` regexes: paths come from scanned, untrusted repos,
+// so a `.+`-based pattern that re-anchors on every `/<dir>/` is a ReDoS risk.
+function isUnderDirSegment(rel: string, segment: string): boolean {
+  const lastSlash = rel.lastIndexOf('/');
+  if (lastSlash < 0) return false;
+  return rel.slice(0, lastSlash).split('/').includes(segment);
+}
+
+// File under a `composables/` directory with a JS/TS extension (js/ts/mjs/mts/cjs/cts).
+export function isNuxtComposablePath(rel: string): boolean {
+  return NUXT_COMPOSABLE_EXT.test(rel) && isUnderDirSegment(rel, 'composables');
+}
+
+function buildComposableRegistry(
+  parsed: ParsedFile[],
+  framework: Framework | undefined,
+): Map<string, string> {
+  const registry = new Map<string, string>();
+  if (framework !== 'nuxt') return registry;
+  for (const file of parsed) {
+    if (!isNuxtComposablePath(file.relPath)) continue;
+    const names = new Set<string>();
+    for (const exp of file.exports) if (exp !== 'default') names.add(exp);
+    const slash = file.relPath.lastIndexOf('/');
+    const dot = file.relPath.lastIndexOf('.');
+    const base = file.relPath.slice(slash + 1, dot);
+    if (base.length > 0) names.add(base);
+    for (const name of names) if (!registry.has(name)) registry.set(name, file.relPath);
+  }
+  return registry;
+}
+
 function indexFilesByDir(files: string[]): Map<string, string[]> {
   const map = new Map<string, string[]>();
   for (const f of files) {
@@ -599,10 +667,14 @@ function frameworkFactsFromPath(
   ) {
     facts.push({ kind: 'sveltekit-route', value: relPath, confidence: 'medium' });
   }
-  if (framework === 'nuxt' && /(^|\/)components\/.+\.vue$/u.test(relPath)) {
+  if (
+    framework === 'nuxt' &&
+    relPath.endsWith('.vue') &&
+    isUnderDirSegment(relPath, 'components')
+  ) {
     facts.push({ kind: 'nuxt-auto-component', value: relPath, confidence: 'medium' });
   }
-  if (framework === 'nuxt' && /(^|\/)composables\/.+\.[cm]?[jt]s$/u.test(relPath)) {
+  if (framework === 'nuxt' && isNuxtComposablePath(relPath)) {
     facts.push({ kind: 'nuxt-auto-composable', value: relPath, confidence: 'medium' });
   }
   return facts;

package/src/analyzer/bundle/analyzeBundle.ts

@@ -6,7 +6,7 @@
 // are kept on the chunk for size accounting but don't surface as recs (we'd
 // flag them as "external" otherwise, which is noise on every chunk).
 
-import type { ModuleId, ModuleNode } from '../types';
+import type { DependencyEdge, ModuleId, ModuleNode } from '../types';
 import {
   DEFAULT_BUNDLE_THRESHOLDS,
   type BundleBloat,
@@ -22,6 +22,8 @@ export interface AnalyzeBundleInput {
   modules: ModuleNode[];
   stats: ParsedBundleStats;
   thresholds?: Partial<BundleThresholds>;
+  /** Edge graph: needed for barrel-leak (re-export hubs). Without it the signal is skipped. */
+  edges?: DependencyEdge[];
 }
 
 export function analyzeBundle(input: AnalyzeBundleInput): BundleReport {
@@ -48,6 +50,18 @@ export function analyzeBundle(input: AnalyzeBundleInput): BundleReport {
 
   const totalSize = chunks.reduce((acc, c) => acc + c.size, 0);
   const bloat = detectBloat(chunks, moduleToChunks, thresholds);
+  if (input.edges && input.edges.length > 0) {
+    bloat.push(
+      ...detectBarrelLeaks(
+        input.modules,
+        input.edges,
+        moduleToChunks,
+        chunks,
+        thresholds,
+        bloat.length,
+      ),
+    );
+  }
 
   return {
     format: input.stats.format,
@@ -140,6 +154,75 @@ function detectBloat(
   return out;
 }
 
+const BARREL_NAME_RE = /(^|\/)index\.[cm]?[jt]sx?$/u;
+
+// barrel-leak: a barrel (re-export hub `index.*`) pulls a large share of its
+// re-export targets into one chunk. Symptom of failed tree-shaking — importing the
+// barrel drags the whole directory into the bundle. A "graph × bundle" signal that
+// pure stats tools can't produce: targets come from the import graph, co-location
+// from the chunks.
+function detectBarrelLeaks(
+  modules: ModuleNode[],
+  edges: DependencyEdge[],
+  moduleToChunks: Record<ModuleId, string[]>,
+  chunks: BundleChunk[],
+  thresholds: BundleThresholds,
+  startSerial: number,
+): BundleBloat[] {
+  const out: BundleBloat[] = [];
+  let serial = startSerial;
+
+  const outgoing = new Map<ModuleId, Set<ModuleId>>();
+  for (const e of edges) {
+    if (e.kind === 'type-only') continue;
+    let bucket = outgoing.get(e.from);
+    if (!bucket) {
+      bucket = new Set();
+      outgoing.set(e.from, bucket);
+    }
+    bucket.add(e.to);
+  }
+
+  for (const b of modules) {
+    if (!BARREL_NAME_RE.test(b.id)) continue;
+    const bChunks = moduleToChunks[b.id];
+    if (!bChunks || bChunks.length === 0) continue;
+    const dir = b.id.slice(0, b.id.lastIndexOf('/') + 1);
+    // re-export targets in the barrel's subtree (a barrel almost always re-exports siblings)
+    const targets = [...(outgoing.get(b.id) ?? [])].filter((t) => t !== b.id && t.startsWith(dir));
+    if (targets.length < thresholds.barrelMinModules) continue;
+
+    const bChunkSet = new Set(bChunks);
+    const colocated = targets.filter((t) =>
+      (moduleToChunks[t] ?? []).some((c) => bChunkSet.has(c)),
+    );
+    const share = colocated.length / targets.length;
+    if (colocated.length < thresholds.barrelMinModules || share < thresholds.barrelLeakShare) {
+      continue;
+    }
+
+    const colocatedSet = new Set(colocated);
+    let sizeBytes = 0;
+    for (const c of chunks) {
+      if (!bChunkSet.has(c.id)) continue;
+      for (const m of c.modules)
+        if (m.moduleId && colocatedSet.has(m.moduleId)) sizeBytes += m.size;
+    }
+
+    out.push({
+      id: `bundle:barrel:${serial++}:${b.id}`,
+      kind: 'barrel-leak',
+      severity: colocated.length >= thresholds.barrelMinModules * 2 ? 'high' : 'medium',
+      message: `Barrel "${displayShortId(b.id)}" pulls ${colocated.length}/${targets.length} re-exported modules into the same chunk (tree-shaking leak)`,
+      modules: [b.id],
+      chunks: [...bChunkSet],
+      detail: { sizeBytes, moduleCount: colocated.length },
+    });
+  }
+
+  return out;
+}
+
 function formatBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;

package/src/analyzer/bundle/types.ts

@@ -29,7 +29,7 @@ export interface BundleChunkModule {
   size: number;
 }
 
-export type BundleBloatKind = 'duplicate' | 'heavy-chunk' | 'solo-hot';
+export type BundleBloatKind = 'duplicate' | 'heavy-chunk' | 'solo-hot' | 'barrel-leak';
 
 export interface BundleBloat {
   /** Stable id for grouping/diffing. */
@@ -47,6 +47,8 @@ export interface BundleBloat {
     sizeBytes?: number;
     chunkCount?: number;
     sharePercent?: number;
+    /** barrel-leak: number of the barrel's re-export targets that landed in the same chunk. */
+    moduleCount?: number;
   };
 }
 
@@ -70,12 +72,18 @@ export interface BundleThresholds {
   duplicateMinChunks: number;
   /** Module taking >= share of a heavy chunk triggers `solo-hot` (0..1). */
   soloHotShare: number;
+  /** Barrel re-exporting >= N same-tree modules is a `barrel-leak` candidate. */
+  barrelMinModules: number;
+  /** Share of a barrel's re-export targets co-located in its chunk to flag (0..1). */
+  barrelLeakShare: number;
 }
 
 export const DEFAULT_BUNDLE_THRESHOLDS: BundleThresholds = {
   heavyChunkBytes: 500_000,
   duplicateMinChunks: 2,
   soloHotShare: 0.8,
+  barrelMinModules: 8,
+  barrelLeakShare: 0.8,
 };
 
 /** Parsed-but-not-yet-analyzed stats. Produced by the format parsers. */

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

@@ -1,13 +1,12 @@
-// Инкрементальный пере-скан: на вход — предыдущий ScanResult и список
-// изменённых относительных путей. Если все изменения — это «pure modify»
-// существующих модулей со static-импортами, переразрешаем только их
-// outgoing-рёбра и пересчитываем downstream-метрики/циклы. Иначе fallback
-// на полный `analyze()`.
+// Incremental rescan: takes the previous ScanResult and a list of changed
+// relative paths. If every change is a "pure modify" of existing modules with
+// static imports, we only re-resolve their outgoing edges and recompute
+// downstream metrics/cycles. Otherwise we fall back to a full `analyze()`.
 //
-// Подход «простой вариант» из плана 15.2: оптимизация только для типичного
-// IDE-save сценария. Глоб/префикс-импорты, auto-import шаблонов, изменения
-// конфигов и добавление/удаление файлов перенаправляются в полный пайплайн —
-// корректность важнее скорости, а эти случаи редки на сохранении одного файла.
+// The "simple variant" from plan 15.2: optimize only the typical IDE-save
+// scenario. Glob/prefix imports, template auto-imports, config changes and
+// file add/remove are routed through the full pipeline - correctness matters
+// more than speed, and these cases are rare when saving a single file.
 
 import type { FileSource } from './fileSource';
 import type {
@@ -26,7 +25,8 @@ import { loadAliases } from './loadAliases';
 import { createResolver } from './resolve';
 import { createParserRegistry, isParseFailure } from './parsers';
 import { classifyKind, isInfra } from './classify';
-import { classifyModuleRuntime, detectRscLeaks } from './rsc';
+import { isNuxtComposablePath } from './buildGraph';
+import { classifyModuleRuntime, detectRscLeaks, isServerActionsModule } from './rsc';
 import { detectCycles } from './cycles';
 import { computeMetrics } from './metrics';
 import { rankHotZones } from './hotZones';
@@ -148,6 +148,17 @@ export async function incrementalAnalyze(input: IncrementalAnalyzeInput): Promis
     if (result.templateRefs && result.templateRefs.length > 0) {
       return analyze(source, options);
     }
+    // Nuxt composable auto-import edges are built from the full file list
+    // (the composables/** registry crossed with consumer call identifiers) -
+    // like glob/templateRefs, they can only be safely recomputed by a cold scan.
+    if (prev.project.detectedFramework === 'nuxt') {
+      if (
+        isNuxtComposablePath(rel) ||
+        (result.callIdentifiers && result.callIdentifiers.length > 0)
+      ) {
+        return analyze(source, options);
+      }
+    }
     reparsed.set(rel, result);
   }
 
@@ -173,7 +184,14 @@ export async function incrementalAnalyze(input: IncrementalAnalyzeInput): Promis
         relPath: p.relPath,
         framework: prev.project.detectedFramework as Framework,
         ...(p.directives ? { directives: p.directives } : {}),
+        ...(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 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({
@@ -209,6 +210,7 @@ export async function analyze(
   const bundle = effectiveBundleStats
     ? analyzeBundle({
         modules,
+        edges,
         stats: effectiveBundleStats,
         ...(Object.keys(bundleThresholds).length > 0 ? { thresholds: bundleThresholds } : {}),
       })

package/src/analyzer/loadAliases.ts

@@ -1,7 +1,7 @@
-// Загрузка path-aliases из tsconfig (с цепочкой `extends`) и Vite-конфига.
-// Вынесено из `analyze()` для переиспользования в `incrementalAnalyze()` —
-// при пере-сканировании одного файла нам нужен тот же резолвер, что и при
-// полном анализе, иначе разрешение `@/*` сломается на ходу.
+// Loads path aliases from tsconfig (following the `extends` chain) and the
+// Vite config. Pulled out of `analyze()` so `incrementalAnalyze()` can reuse
+// it - a single-file rescan needs the same resolver as a full analysis,
+// otherwise `@/*` resolution breaks midway.
 
 import type { FileSource } from './fileSource';
 import type { ProjectRef } from './types';

package/src/analyzer/memoryRisk.ts

@@ -41,7 +41,7 @@ const PATTERNS: readonly RiskPattern[] = [
     kind: 'timer-cleanup',
     acquire: 'setTimeout',
     cleanup: 'clearTimeout',
-    testAcquire: isNamedCall('setTimeout'),
+    testAcquire: isCapturedTimer('setTimeout'),
     testCleanup: isNamedCall('clearTimeout'),
   },
   {
@@ -81,7 +81,9 @@ export async function detectMemoryRisks(
       module.id,
       script,
       ts.ScriptTarget.Latest,
-      false,
+      // Parent links are needed to tell a captured `setTimeout` handle from a
+      // discarded fire-and-forget call (see isCapturedResult).
+      true,
       scriptKindFor(module.id),
     );
     const context: RiskContext = {
@@ -255,6 +257,35 @@ function isNamedCall(name: string): (node: ts.Node) => boolean {
   return (node) => ts.isCallExpression(node) && callName(node.expression) === name;
 }
 
+// A bare `setTimeout(fn, n)` expression statement is fire-and-forget and needs no
+// cleanup. Flag only when the timer id is captured (assigned, stored on a property,
+// returned, or passed on), since a kept handle signals the author intended it to be
+// cancellable and leaving it uncleared is the suspicious case.
+function isCapturedTimer(name: string): (node: ts.Node) => boolean {
+  const matchesCall = isNamedCall(name);
+  return (node) => matchesCall(node) && isCapturedResult(node);
+}
+
+function isCapturedResult(node: ts.Node): boolean {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (ts.isVariableDeclaration(parent)) return parent.initializer === node;
+  if (ts.isPropertyDeclaration(parent)) return parent.initializer === node;
+  if (ts.isPropertyAssignment(parent)) return parent.initializer === node;
+  if (ts.isBinaryExpression(parent)) {
+    return parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.right === node;
+  }
+  if (ts.isReturnStatement(parent)) return parent.expression === node;
+  if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) {
+    return parent.arguments?.some((arg) => arg === node) ?? false;
+  }
+  // Parenthesized / as-expression wrappers keep the handle reachable.
+  if (ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent)) {
+    return isCapturedResult(parent);
+  }
+  return false;
+}
+
 function isIdentifierCall(node: ts.CallExpression, name: string): boolean {
   return ts.isIdentifier(node.expression) && node.expression.text === name;
 }

package/src/analyzer/metrics.ts

@@ -1,5 +1,11 @@
 import type { Cycle, DependencyEdge, ModuleId, ModuleMetrics, ModuleNode } from './types';
 
+// Hotness premium for cycle membership: a module in an SCC is riskier than an
+// equally-coupled module outside one (changes ripple both ways). 1.5 = a modest
+// +50%: cycle membership lifts the score but does not override coupling itself.
+// Heuristic default, justified ordinally (cycle > non-cycle), not data-calibrated.
+const CYCLE_HOTNESS_MULTIPLIER = 1.5;
+
 export interface ComputeMetricsInput {
   modules: ModuleNode[];
   edges: DependencyEdge[];
@@ -56,8 +62,11 @@ export function computeMetrics(input: ComputeMetricsInput): Record<ModuleId, Mod
     const instability = sum === 0 ? 0 : fo / sum;
     const cycle = inCycle.has(id);
     const coupling = maxCoupling === 0 ? 0 : (rawCoupling.get(id) ?? 0) / maxCoupling;
+    // sizeFactor ∈ [1, 2]: size, log2-normalized against the largest file. log
+    // (not linear) so one giant file doesn't dominate; the upper bound of 2 caps
+    // the size contribution at a doubling.
     const sizeFactor = maxLoc === 0 ? 1 : 1 + Math.log2(1 + m.loc) / Math.log2(1 + maxLoc);
-    const hotness = coupling * (cycle ? 1.5 : 1) * sizeFactor;
+    const hotness = coupling * (cycle ? CYCLE_HOTNESS_MULTIPLIER : 1) * sizeFactor;
     result[id] = {
       fanIn: fi,
       fanOut: fo,

package/src/analyzer/parsers/svelteParser.ts

@@ -1,3 +1,8 @@
+// Beta: extracts script blocks with a regex, without svelte/compiler. Picks up
+// imports (static and dynamic) from `<script>` and `<script context="module">`;
+// the template and `$:` are not parsed (Svelte resolves components via script
+// imports anyway). First-class targets are Vue/React/Nuxt/Next; Svelte is
+// deliberately left short of full AST parsing.
 import type { ParsedFile } from '../types';
 import type { TsParser } from './tsParser';
 

package/src/analyzer/parsers/tsParser.ts

@@ -39,6 +39,7 @@ export function createTsParser(options: TsParserOptions = {}): TsParser {
 
       const imports: RawImport[] = [];
       const exports = new Set<string>();
+      const callees = new Set<string>();
       let hasDefineStore = false;
 
       visit(
@@ -46,6 +47,7 @@ export function createTsParser(options: TsParserOptions = {}): TsParser {
         sf,
         imports,
         exports,
+        callees,
         () => {
           hasDefineStore = true;
         },
@@ -62,6 +64,7 @@ export function createTsParser(options: TsParserOptions = {}): TsParser {
         exports: [...exports].sort(),
         hasDefineStore: hasDefineStore || /\bdefineStore\s*\(/.test(input.content),
         ...(directives.length > 0 ? { directives } : {}),
+        ...(callees.size > 0 ? { callIdentifiers: [...callees].sort() } : {}),
       };
     },
   };
@@ -78,9 +81,14 @@ function visit(
   sf: ts.SourceFile,
   imports: RawImport[],
   exports: Set<string>,
+  callees: Set<string>,
   markDefineStore: () => void,
   loaders: DynamicLoaderConfig[],
 ): void {
+  if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+    callees.add(node.expression.text);
+  }
+
   if (ts.isImportDeclaration(node)) {
     const spec = literalText(node.moduleSpecifier);
     if (spec !== null) {
@@ -208,7 +216,9 @@ function visit(
     exports.add('default');
   }
 
-  ts.forEachChild(node, (child) => visit(child, sf, imports, exports, markDefineStore, loaders));
+  ts.forEachChild(node, (child) =>
+    visit(child, sf, imports, exports, callees, markDefineStore, loaders),
+  );
 }
 
 function literalText(node: ts.Node): string | null {