nuxt-layerscope 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.1.4
+
+- Packages that Nuxt hoists into the generated tsconfig `paths` (`ofetch`, `consola`, `h3`, `defu`,
+  `nitropack`) are no longer reported as unresolved imports.
+- The DevTools tab serves JSON endpoints under `/__layerscope/api` (`state`, `report`, `rerun`),
+  with an `ETag` revision that only changes when the findings, layers or notes change.
+- `eslint --cache` no longer keeps stale results: `configs.recommended` carries a digest of the
+  registry and the layer config, so ESLint discards cached results when either changes.
+- The ESLint plugin no longer reuses a file's last result after the registry or config changed,
+  which showed stale findings in editors until the file's text changed.
+- The DevTools tab re-analyzes only files that changed since the last run.
+- The DevTools tab reads `layerscope-baseline.json`, so accepted findings are left out and counted
+  as "in baseline", like `layerscope check`.
+
+## 0.1.3
+
+- Notes and the `--verbose` line are printed after the report, in every command, so they are the
+  last thing on screen. `note:` is highlighted in a terminal.
+- `layerscope check` lists files with errors after files with only warnings, so the errors stay
+  next to the summary in a long report.
+- The text report colors severities, rule names and the summary in a terminal. `NO_COLOR` and
+  `FORCE_COLOR` are honoured.
+
 ## 0.1.2
 
 - A note appears when `nuxt.config` is newer than the registry, because changes to its

package/dist/{analyze-QaYmBXyK.mjs → analyze-BwmKhroS.mjs}

@@ -1,104 +1,11 @@
-import { c as realPath, d as effectiveConfig, f as labelConfigError, g as ruleSeverity, h as isRuleName, s as readJson, v as LayerscopeError } from "./layer-factory-DFh7nkFH.mjs";
+import { E as LayerscopeError, b as labelConfigError, f as collectFiles, v as realPath, w as ruleSeverity, y as effectiveConfig } from "./layer-factory-DVSf2Wj4.mjs";
 import { r as pascalCase, t as compareStrings } from "./strings-CrOjNZmB.mjs";
-import { t as globComponents } from "./component-files-DgOXNE6l.mjs";
-import { c as createOwnerLookup, d as createAnalysisEnv, f as readRegistry, h as boundaryFindings, m as loadSymbolTable, n as analyzeFile, p as tableFromRegistry, r as collectFiles, u as resolveLayers, v as loadConfig } from "./file-analysis-Bh7qcWUK.mjs";
+import { o as applyBaselineFile, r as analyzeFiles, t as globComponents } from "./component-files-B_qvkKwv.mjs";
+import { a as readRegistry, c as boundaryFindings, d as loadConfig, i as createAnalysisEnv, o as tableFromRegistry, r as resolveLayers, s as loadSymbolTable, t as createOwnerLookup } from "./owner-BA00V9VD.mjs";
 import { basename, extname, join, relative, resolve } from "pathe";
-import { existsSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { escapePath, glob } from "tinyglobby";
 import { spawnSync } from "node:child_process";
-//#region src/baseline/index.ts
-const BASELINE_FILE = "layerscope-baseline.json";
-/** Bumped on breaking changes to the baseline file. */
-const BASELINE_VERSION = 1;
-/** Rule, file, symbol and target layer; lines are left out so unrelated edits keep the entry. */
-function keyOf(entry) {
-	return [
-		entry.rule,
-		entry.file,
-		entry.symbol,
-		entry.toLayer ?? ""
-	].join("\0");
-}
-function toKeyed(finding, rootDir) {
-	return {
-		rule: finding.rule,
-		file: relative(rootDir, finding.file),
-		symbol: finding.symbol,
-		toLayer: finding.toLayer
-	};
-}
-function compareEntries(a, b) {
-	return compareStrings(a.file, b.file) || compareStrings(a.rule, b.rule) || compareStrings(a.symbol, b.symbol) || compareStrings(a.toLayer ?? "", b.toLayer ?? "");
-}
-function createBaseline(findings, rootDir) {
-	const entries = /* @__PURE__ */ new Map();
-	for (const finding of findings) {
-		const keyed = toKeyed(finding, rootDir);
-		const key = keyOf(keyed);
-		const entry = entries.get(key);
-		if (entry === void 0) entries.set(key, keyed);
-		else entry.count = (entry.count ?? 1) + 1;
-	}
-	return {
-		version: 1,
-		entries: [...entries.values()].toSorted(compareEntries)
-	};
-}
-function writeBaseline(file, baseline) {
-	writeFileSync(file, `${JSON.stringify(baseline, null, 2)}\n`);
-}
-function isEntry(value) {
-	const entry = value;
-	return typeof entry === "object" && entry !== null && typeof entry.rule === "string" && isRuleName(entry.rule) && typeof entry.file === "string" && typeof entry.symbol === "string" && (entry.toLayer === null || typeof entry.toLayer === "string");
-}
-function readBaseline(file) {
-	if (!existsSync(file)) return null;
-	const baseline = readJson(file);
-	if (baseline?.version !== 1 || !Array.isArray(baseline.entries)) throw new LayerscopeError(`${file} is not a layerscope baseline (version 1). Recreate it with --update-baseline.`);
-	const invalid = baseline.entries.findIndex((entry) => !isEntry(entry));
-	if (invalid !== -1) throw new LayerscopeError(`${file}: entry ${invalid} is not a valid baseline entry`);
-	return {
-		version: 1,
-		entries: baseline.entries
-	};
-}
-/** Findings missing from the baseline stay; the rest are suppressed, up to each entry's count. */
-function applyBaseline(findings, baseline, file, rootDir) {
-	const remaining = new Map(baseline.entries.map((entry) => [keyOf(entry), {
-		entry,
-		left: entry.count ?? 1
-	}]));
-	const fresh = [];
-	const suppressed = [];
-	for (const finding of findings) {
-		const slot = remaining.get(keyOf(toKeyed(finding, rootDir)));
-		if (slot === void 0 || slot.left === 0) fresh.push(finding);
-		else {
-			slot.left -= 1;
-			suppressed.push(finding);
-		}
-	}
-	return {
-		findings: fresh,
-		baseline: {
-			file,
-			suppressed,
-			removable: [...remaining.values()].flatMap(({ entry, left }) => left === 0 ? [] : [left === (entry.count ?? 1) ? entry : {
-				...entry,
-				count: left
-			}])
-		}
-	};
-}
-/** The result with the baseline applied, or unchanged when the file does not exist. */
-function applyBaselineFile(result, file) {
-	const baseline = readBaseline(file);
-	return baseline === null ? result : {
-		...result,
-		...applyBaseline(result.findings, baseline, file, result.rootDir)
-	};
-}
-//#endregion
 //#region src/rules/compare.ts
 /** Total order on position, then rule or kind, then symbol, for deterministic reports. */
 function compareByPosition(a, b) {
@@ -335,7 +242,7 @@ async function analyze(options = {}) {
 	});
 	const { layers, env, registry, config } = environment;
 	const files = await collectFiles(layers, env.ownerOf, config.ignore ?? []);
-	const analyses = [...files].map(([file, layer]) => analyzeFile(file, layer, env));
+	const analyses = analyzeFiles(files, env, options.cache, options.envKey);
 	const edges = analyses.flatMap((analysis) => analysis.edges).toSorted(compareByPosition);
 	const { findings, notes } = runRules({
 		edges,
@@ -360,4 +267,4 @@ async function analyze(options = {}) {
 	return options.baseline === void 0 ? result : applyBaselineFile(result, resolve(rootDir, options.baseline));
 }
 //#endregion
-export { writeBaseline as a, createBaseline as i, BASELINE_FILE as n, BASELINE_VERSION as r, analyze as t };
+export { analyze as t };

package/dist/analyze-vZUz30sN.mjs

@@ -0,0 +1,2 @@
+import { t as analyze } from "./analyze-BwmKhroS.mjs";
+export { analyze };

package/dist/api.d.mts

@@ -1,5 +1,93 @@
-import { a as Context, c as Layer, d as Reference, f as ReferenceKind, g as SourceOption, h as Severity, i as BaselineResult, l as LayerRule, m as RuleName, n as AnalyzeResult, o as Edge, p as ResolutionSource, r as BaselineEntry, s as Finding, t as defineConfig, u as LayerscopeConfig } from "./define-DNRGLVG_.mjs";
-import { t as ProjectConfig } from "./effective-Dqg4EwH_.mjs";
+import { _ as SymbolTable, a as Context, c as Layer, d as Reference, f as ReferenceKind, g as SourceOption, h as Severity, i as BaselineResult, l as LayerRule, m as RuleName, n as AnalyzeResult, o as Edge, p as ResolutionSource, r as BaselineEntry, s as Finding, t as defineConfig, u as LayerscopeConfig } from "./define-DDg4HQRH.mjs";
+import { t as ProjectConfig } from "./effective-BPMNHe9A.mjs";
+import { styleText } from "node:util";
+//#region src/nuxt/owner.d.ts
+type OwnerLookup = (file: string) => Layer | null;
+//#endregion
+//#region src/scan/types.d.ts
+/** References found in one source file. Offsets point into the original file. */
+interface FileScan {
+  /** Identifiers without a local binding. */
+  free: Named[];
+  /** Identifiers a template reads from the component instance (`_ctx.x`). */
+  templateIdents: Named[];
+  components: Named[];
+  /** Offsets of `<component :is>` bound to a runtime value. */
+  dynamicComponents: number[];
+  imports: ImportRef[];
+  /** Set when the file could not be parsed; nothing else in it was analyzed. */
+  error: {
+    message: string;
+    offset: number;
+  } | null;
+}
+interface Named {
+  name: string;
+  offset: number;
+}
+interface ImportRef {
+  specifier: string;
+  /** Export names, with `default` and `*` for default and namespace imports. */
+  names: string[];
+  offset: number;
+}
+//#endregion
+//#region src/nuxt/aliases.d.ts
+/** Alias → absolute path or bare module, longest alias first. */
+type AliasMap = [string, string][];
+//#endregion
+//#region src/analyze/import-refs.d.ts
+interface ImportEnv {
+  table: SymbolTable;
+  aliases: AliasMap;
+  buildDir: string;
+}
+//#endregion
+//#region src/analyze/file-analysis.d.ts
+interface AnalysisEnv extends ImportEnv {
+  ownerOf: OwnerLookup;
+  identifiers: Set<string>;
+  components: Set<string>;
+  unresolvedSeverity: Severity;
+}
+/** Turns one file's scan into dependency edges and unresolved-reference findings. */
+declare class FileAnalysis {
+  readonly edges: Edge[];
+  readonly unresolved: Finding[];
+  /** Renders a component chosen at runtime, so any component may be used. */
+  hasDynamicComponent: boolean;
+  private readonly seen;
+  readonly file: string;
+  private readonly source;
+  private readonly layer;
+  private readonly env;
+  private readonly context;
+  constructor(file: string, source: string, layer: Layer, env: AnalysisEnv);
+  run(scan: FileScan): this;
+  private addIdentifiers;
+  private addComponents;
+  private addImports;
+  private reference;
+  /** Only the first use of a symbol per file is recorded. */
+  private firstSeen;
+  private addEdge;
+  private addUnresolved;
+}
+//#endregion
+//#region src/analyze/cache.d.ts
+/**
+ * Keeps one file's analysis until its mtime or size changes. Analyses depend on the symbol table,
+ * so a changed `envKey` (registry, generated types, config) drops everything.
+ */
+declare class AnalysisCache {
+  private envKey;
+  private readonly entries;
+  get size(): number;
+  reset(envKey: string): void;
+  get(file: string, compute: () => FileAnalysis): FileAnalysis;
+  retain(files: Iterable<string>): void;
+}
+//#endregion
 //#region src/analyze/index.d.ts
 interface AnalyzeOptions {
   /** Defaults to `process.cwd()`. */
@@ -17,6 +105,10 @@ interface AnalyzeOptions {
    * Ignored when the file does not exist.
    */
   baseline?: string;
+  /** Reuses per-file analyses across runs. Used by the DevTools tab; the CLI passes none. */
+  cache?: AnalysisCache;
+  /** Changes when the symbol table or config changes, which flushes `cache`. */
+  envKey?: string;
 }
 export declare function analyze(options?: AnalyzeOptions): Promise<AnalyzeResult>;
 //#endregion
@@ -114,11 +206,15 @@ interface Registry {
   config?: ProjectConfig;
 }
 //#endregion
+//#region src/utils/style.d.ts
+/** Wraps text in terminal styles, e.g. `paint('red', 'error')`. */
+type Paint = (format: Parameters<typeof styleText>[0], text: string) => string;
+//#endregion
 //#region src/report/index.d.ts
 export declare const OUTPUT_FORMATS: readonly ['text', 'github', 'json'];
 type OutputFormat = (typeof OUTPUT_FORMATS)[number];
-/** Paths in the output are relative to `cwd`. */
-export declare function formatResult(result: AnalyzeResult, format: OutputFormat, cwd?: string): string;
+/** Paths in the output are relative to `cwd`. Only the text format uses `paint`. */
+export declare function formatResult(result: AnalyzeResult, format: OutputFormat, cwd?: string, paint?: Paint): string;
 //#endregion
 //#region src/report/json.d.ts
 /** Bumped on breaking changes to the JSON report shape. */

package/dist/api.mjs

@@ -1,6 +1,7 @@
-import { l as REGISTRY_FILE, u as REGISTRY_VERSION, v as LayerscopeError } from "./layer-factory-DFh7nkFH.mjs";
+import { E as LayerscopeError, o as REGISTRY_FILE, s as REGISTRY_VERSION } from "./layer-factory-DVSf2Wj4.mjs";
+import { a as BASELINE_VERSION, i as BASELINE_FILE, s as createBaseline } from "./component-files-B_qvkKwv.mjs";
 import { t as defineConfig } from "./define-l62B9fVk.mjs";
-import { i as createBaseline, n as BASELINE_FILE, r as BASELINE_VERSION, t as analyze } from "./analyze-QaYmBXyK.mjs";
-import { i as JSON_REPORT_VERSION, n as formatResult, t as OUTPUT_FORMATS } from "./report-BNW0GCl9.mjs";
-import { r as buildGraph, t as findUnused } from "./unused-BtsPSfxb.mjs";
+import { t as analyze } from "./analyze-BwmKhroS.mjs";
+import { i as JSON_REPORT_VERSION, n as formatResult, t as OUTPUT_FORMATS } from "./report-jEMtNXS8.mjs";
+import { r as buildGraph, t as findUnused } from "./unused-DbvZ4gRV.mjs";
 export { BASELINE_FILE, BASELINE_VERSION, JSON_REPORT_VERSION, LayerscopeError, OUTPUT_FORMATS, REGISTRY_FILE, REGISTRY_VERSION, analyze, buildGraph, createBaseline, defineConfig, findUnused, formatResult };

package/dist/bin.mjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { v as LayerscopeError } from "./layer-factory-DFh7nkFH.mjs";
+import { E as LayerscopeError } from "./layer-factory-DVSf2Wj4.mjs";
 import { i as plural, r as pascalCase } from "./strings-CrOjNZmB.mjs";
-import { a as writeBaseline, i as createBaseline, n as BASELINE_FILE, t as analyze } from "./analyze-QaYmBXyK.mjs";
-import { n as formatResult, r as isOutputFormat, t as OUTPUT_FORMATS } from "./report-BNW0GCl9.mjs";
-import { i as edgeStatus, n as GRAPH_LEVELS, r as buildGraph, t as findUnused } from "./unused-BtsPSfxb.mjs";
+import { c as writeBaseline, i as BASELINE_FILE, s as createBaseline } from "./component-files-B_qvkKwv.mjs";
+import { t as analyze } from "./analyze-BwmKhroS.mjs";
+import { a as paintFor, n as formatResult, r as isOutputFormat, t as OUTPUT_FORMATS } from "./report-jEMtNXS8.mjs";
+import { i as edgeStatus, n as GRAPH_LEVELS, r as buildGraph, t as findUnused } from "./unused-DbvZ4gRV.mjs";
 import { relative, resolve } from "pathe";
 import { cac } from "cac";
 //#region src/commands/shared.ts
@@ -20,14 +21,19 @@ function toSource(value) {
 	if (source === void 0) throw new LayerscopeError(`Unknown source "${value}". Use ${SOURCE_OPTIONS.join(", ")}.`);
 	return source;
 }
-/** Diagnostics go to stderr, so stdout stays machine-readable in every format. */
+/**
+* Diagnostics go to stderr, so stdout stays machine-readable in every format. Call it after the
+* report is written: notes at the end are the ones a reader still sees when the report scrolled.
+*/
 function writeNotes(result, verbose) {
-	const lines = result.notes.map((note) => `layerscope: note: ${note}`);
+	const paint = paintFor(process.stderr);
+	const lines = result.notes.map((note) => `${paint(["yellow", "bold"], "layerscope: note:")} ${note}`);
 	if (verbose) {
 		const kind = result.source === "registry" ? "the registry" : "the generated .d.ts files";
-		lines.unshift(`layerscope: symbols from ${kind} (${relative(process.cwd(), result.sourceFile)})`);
+		const source = relative(process.cwd(), result.sourceFile);
+		lines.unshift(paint("dim", `layerscope: symbols from ${kind} (${source})`));
 	}
-	if (lines.length > 0) process.stderr.write(`${lines.join("\n")}\n`);
+	if (lines.length > 0) process.stderr.write(`${process.stdout.isTTY ? "\n" : ""}${lines.join("\n")}\n`);
 }
 //#endregion
 //#region src/commands/check.ts
@@ -38,11 +44,11 @@ async function updateBaseline(rootDir, flags) {
 		prepare: flags.prepare,
 		source: toSource(flags.source)
 	});
-	writeNotes(result, flags.verbose === true);
 	const file = resolve(rootDir, flags.baseline);
 	writeBaseline(file, createBaseline(result.findings, rootDir));
 	const count = plural(result.findings.length, "finding");
 	process.stdout.write(`✔ Wrote ${count} to ${relative(process.cwd(), file)}\n`);
+	writeNotes(result, flags.verbose === true);
 	return 0;
 }
 async function check(root, flags) {
@@ -57,8 +63,8 @@ async function check(root, flags) {
 		source: toSource(flags.source),
 		baseline: flags.baseline
 	});
+	process.stdout.write(formatResult(result, format, process.cwd(), paintFor(process.stdout)));
 	writeNotes(result, flags.verbose === true);
-	process.stdout.write(formatResult(result, format));
 	return result.findings.some((finding) => finding.severity === "error") ? 1 : 0;
 }
 function registerCheck(cli) {
@@ -162,8 +168,8 @@ async function graph(root, flags) {
 		prepare: flags.prepare,
 		source: toSource(flags.source)
 	});
-	writeNotes(result, flags.verbose === true);
 	process.stdout.write(formatGraph(buildGraph(result, result.config, level), format));
+	writeNotes(result, flags.verbose === true);
 	return 0;
 }
 function registerGraph(cli) {
@@ -216,8 +222,8 @@ async function unused(root, flags) {
 		prepare: flags.prepare,
 		source: toSource(flags.source)
 	});
-	writeNotes(result, flags.verbose === true);
 	process.stdout.write(formatUnused(findUnused(result), format));
+	writeNotes(result, flags.verbose === true);
 	return 0;
 }
 function registerUnused(cli) {
@@ -331,10 +337,13 @@ async function why(symbol, root, flags) {
 		prepare: flags.prepare,
 		source: toSource(flags.source)
 	});
-	writeNotes(result, flags.verbose === true);
 	const targets = findUses(result, symbol, result.config);
-	if (targets.length === 0) throw new LayerscopeError(`No uses of "${symbol}" found.`);
+	if (targets.length === 0) {
+		writeNotes(result, flags.verbose === true);
+		throw new LayerscopeError(`No uses of "${symbol}" found.`);
+	}
 	process.stdout.write(formatWhy(symbol, targets, format));
+	writeNotes(result, flags.verbose === true);
 	return 0;
 }
 function registerWhy(cli) {

package/dist/component-files-B_qvkKwv.mjs

@@ -0,0 +1,153 @@
+import { C as isRuleName, E as LayerscopeError, _ as readJson, l as analyzeFile } from "./layer-factory-DVSf2Wj4.mjs";
+import { t as compareStrings } from "./strings-CrOjNZmB.mjs";
+import { relative } from "pathe";
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { glob } from "tinyglobby";
+//#region src/baseline/index.ts
+const BASELINE_FILE = "layerscope-baseline.json";
+/** Bumped on breaking changes to the baseline file. */
+const BASELINE_VERSION = 1;
+/** Rule, file, symbol and target layer; lines are left out so unrelated edits keep the entry. */
+function keyOf(entry) {
+	return [
+		entry.rule,
+		entry.file,
+		entry.symbol,
+		entry.toLayer ?? ""
+	].join("\0");
+}
+function toKeyed(finding, rootDir) {
+	return {
+		rule: finding.rule,
+		file: relative(rootDir, finding.file),
+		symbol: finding.symbol,
+		toLayer: finding.toLayer
+	};
+}
+function compareEntries(a, b) {
+	return compareStrings(a.file, b.file) || compareStrings(a.rule, b.rule) || compareStrings(a.symbol, b.symbol) || compareStrings(a.toLayer ?? "", b.toLayer ?? "");
+}
+function createBaseline(findings, rootDir) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const finding of findings) {
+		const keyed = toKeyed(finding, rootDir);
+		const key = keyOf(keyed);
+		const entry = entries.get(key);
+		if (entry === void 0) entries.set(key, keyed);
+		else entry.count = (entry.count ?? 1) + 1;
+	}
+	return {
+		version: 1,
+		entries: [...entries.values()].toSorted(compareEntries)
+	};
+}
+function writeBaseline(file, baseline) {
+	writeFileSync(file, `${JSON.stringify(baseline, null, 2)}\n`);
+}
+function isEntry(value) {
+	const entry = value;
+	return typeof entry === "object" && entry !== null && typeof entry.rule === "string" && isRuleName(entry.rule) && typeof entry.file === "string" && typeof entry.symbol === "string" && (entry.toLayer === null || typeof entry.toLayer === "string");
+}
+function readBaseline(file) {
+	if (!existsSync(file)) return null;
+	const baseline = readJson(file);
+	if (baseline?.version !== 1 || !Array.isArray(baseline.entries)) throw new LayerscopeError(`${file} is not a layerscope baseline (version 1). Recreate it with --update-baseline.`);
+	const invalid = baseline.entries.findIndex((entry) => !isEntry(entry));
+	if (invalid !== -1) throw new LayerscopeError(`${file}: entry ${invalid} is not a valid baseline entry`);
+	return {
+		version: 1,
+		entries: baseline.entries
+	};
+}
+/** Findings missing from the baseline stay; the rest are suppressed, up to each entry's count. */
+function applyBaseline(findings, baseline, file, rootDir) {
+	const remaining = new Map(baseline.entries.map((entry) => [keyOf(entry), {
+		entry,
+		left: entry.count ?? 1
+	}]));
+	const fresh = [];
+	const suppressed = [];
+	for (const finding of findings) {
+		const slot = remaining.get(keyOf(toKeyed(finding, rootDir)));
+		if (slot === void 0 || slot.left === 0) fresh.push(finding);
+		else {
+			slot.left -= 1;
+			suppressed.push(finding);
+		}
+	}
+	return {
+		findings: fresh,
+		baseline: {
+			file,
+			suppressed,
+			removable: [...remaining.values()].flatMap(({ entry, left }) => left === 0 ? [] : [left === (entry.count ?? 1) ? entry : {
+				...entry,
+				count: left
+			}])
+		}
+	};
+}
+/** The result with the baseline applied, or unchanged when the file does not exist. */
+function applyBaselineFile(result, file) {
+	const baseline = readBaseline(file);
+	return baseline === null ? result : {
+		...result,
+		...applyBaseline(result.findings, baseline, file, result.rootDir)
+	};
+}
+//#endregion
+//#region src/analyze/cache.ts
+/**
+* Keeps one file's analysis until its mtime or size changes. Analyses depend on the symbol table,
+* so a changed `envKey` (registry, generated types, config) drops everything.
+*/
+var AnalysisCache = class {
+	constructor() {
+		this.envKey = "";
+		this.entries = /* @__PURE__ */ new Map();
+	}
+	get size() {
+		return this.entries.size;
+	}
+	reset(envKey) {
+		if (envKey !== this.envKey) {
+			this.envKey = envKey;
+			this.entries.clear();
+		}
+	}
+	get(file, compute) {
+		const { mtimeMs, size } = statSync(file);
+		const entry = this.entries.get(file);
+		if (entry?.mtimeMs === mtimeMs && entry.size === size) return entry.analysis;
+		const analysis = compute();
+		this.entries.set(file, {
+			mtimeMs,
+			size,
+			analysis
+		});
+		return analysis;
+	}
+	retain(files) {
+		const keep = new Set(files);
+		for (const file of this.entries.keys()) if (!keep.has(file)) this.entries.delete(file);
+	}
+};
+/** Analyzes every file, reusing `cache` entries that are still current. */
+function analyzeFiles(files, env, cache, envKey = "") {
+	cache?.reset(`${envKey}\0${[...files.keys()].toSorted().join("\0")}`);
+	const analyses = [...files].map(([file, layer]) => cache === void 0 ? analyzeFile(file, layer, env) : cache.get(file, () => analyzeFile(file, layer, env)));
+	cache?.retain(files.keys());
+	return analyses;
+}
+//#endregion
+//#region src/registry/component-files.ts
+/** Files in a component dir, matched the way Nuxt's components module scans it. */
+async function globComponents(dir, pattern, ignore) {
+	return (await glob(pattern, {
+		cwd: dir,
+		absolute: true,
+		ignore
+	})).toSorted();
+}
+//#endregion
+export { BASELINE_VERSION as a, writeBaseline as c, BASELINE_FILE as i, AnalysisCache as n, applyBaselineFile as o, analyzeFiles as r, createBaseline as s, globComponents as t };

package/dist/{define-DNRGLVG_.d.mts → define-DDg4HQRH.d.mts}

@@ -123,4 +123,4 @@ interface AnalyzeResult {
 //#region src/config/define.d.ts
 declare function defineConfig(config: LayerscopeConfig): LayerscopeConfig;
 //#endregion
-export { Context as a, Layer as c, Reference as d, ReferenceKind as f, SourceOption as g, Severity as h, BaselineResult as i, LayerRule as l, RuleName as m, AnalyzeResult as n, Edge as o, ResolutionSource as p, BaselineEntry as r, Finding as s, defineConfig as t, LayerscopeConfig as u };
+export { SymbolTable as _, Context as a, Layer as c, Reference as d, ReferenceKind as f, SourceOption as g, Severity as h, BaselineResult as i, LayerRule as l, RuleName as m, AnalyzeResult as n, Edge as o, ResolutionSource as p, BaselineEntry as r, Finding as s, defineConfig as t, LayerscopeConfig as u };

package/dist/define.d.mts

@@ -1,2 +1,2 @@
-import { t as defineConfig } from "./define-DNRGLVG_.mjs";
+import { t as defineConfig } from "./define-DDg4HQRH.mjs";
 export { defineConfig };

package/dist/{effective-Dqg4EwH_.d.mts → effective-BPMNHe9A.d.mts}

@@ -1,4 +1,4 @@
-import { u as LayerscopeConfig } from "./define-DNRGLVG_.mjs";
+import { u as LayerscopeConfig } from "./define-DDg4HQRH.mjs";
 //#region src/config/effective.d.ts
 /** The keys that describe the project; `buildDir` only says where to look. */
 declare const PROJECT_CONFIG_KEYS: readonly ['layers', 'rules', 'ignore', 'globals'];