nuxt-layerscope 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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

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,6 +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()`. */
@@ -18,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

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-DShTCB59.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 { a as paintFor, n as formatResult, r as isOutputFormat, t as OUTPUT_FORMATS } from "./report-DShTCB59.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

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'];

package/dist/eslint.mjs

@@ -1,68 +1,9 @@
-import { d as effectiveConfig, l as REGISTRY_FILE } from "./layer-factory-DFh7nkFH.mjs";
-import { t as packageVersion } from "./version-DFWOUgi5.mjs";
-import { _ as findConfigFile, a as lineColumn, c as createOwnerLookup, d as createAnalysisEnv, f as readRegistry, h as boundaryFindings, i as isCheckedFile, l as nameLayers, o as offsetAt, p as tableFromRegistry, s as scanFile, t as FileAnalysis, y as loadConfigSync } from "./file-analysis-Bh7qcWUK.mjs";
+import { c as FileAnalysis, g as scanFile, h as offsetAt, m as lineColumn, o as REGISTRY_FILE, p as isCheckedFile, y as effectiveConfig } from "./layer-factory-DVSf2Wj4.mjs";
+import { t as packageVersion } from "./version-D5JrgoO_.mjs";
+import { a as readRegistry, c as boundaryFindings, f as loadConfigSync, i as createAnalysisEnv, n as nameLayers, o as tableFromRegistry, t as createOwnerLookup, u as findConfigFile } from "./owner-BA00V9VD.mjs";
 import { dirname, join, relative, resolve } from "pathe";
 import { existsSync, readFileSync, statSync } from "node:fs";
-//#region src/eslint/lint-file.ts
-/** Both rules lint the same text, so the last result per file is reused. */
-const lastLint = /* @__PURE__ */ new Map();
-/**
-* oxlint passes only the `<script>` of a `.vue` file to JS plugins, while the template matters
-* too; the saved file is read instead.
-*/
-function fullSource(file, text) {
-	return file.endsWith(".vue") && !/<(?:script|template)[\s>]/u.test(text) ? readFileSync(file, "utf8") : text;
-}
-/** Lints the text the editor holds, which may differ from the file on disk. */
-function lintFile(file, text, project) {
-	const source = fullSource(file, text);
-	const cached = lastLint.get(file);
-	if (cached?.source === source) return cached.lint;
-	const layer = project.env.ownerOf(file);
-	let lint = {
-		source,
-		boundary: [],
-		unresolved: []
-	};
-	if (layer !== null && isCheckedFile(file, layer, project.config.ignore ?? [])) {
-		const analysis = new FileAnalysis(file, source, layer, project.env).run(scanFile(source, file));
-		lint = {
-			source,
-			boundary: boundaryFindings(analysis.edges, project.config),
-			unresolved: analysis.unresolved
-		};
-	}
-	lastLint.set(file, {
-		source,
-		lint
-	});
-	return lint;
-}
-//#endregion
-//#region src/eslint/location.ts
-/**
-* Maps a finding from the full file into the text the linter passed. ESLint passes the full
-* file; oxlint passes only a `.vue` file's `<script>`, where template findings have no position.
-*/
-function reportLocation(finding, source, text) {
-	if (source === text) return {
-		line: finding.line,
-		column: finding.column,
-		outside: false
-	};
-	const base = source.indexOf(text);
-	const offset = offsetAt(source, finding) - base;
-	if (base === -1 || offset < 0 || offset > text.length) return {
-		line: 1,
-		column: 1,
-		outside: true
-	};
-	return {
-		...lineColumn(text, offset),
-		outside: false
-	};
-}
-//#endregion
+import { createHash } from "node:crypto";
 //#region src/eslint/load-project.ts
 /** Config, layers and symbols of a project, from its registry; Nuxt itself is never loaded. */
 function loadProject(rootDir) {
@@ -98,8 +39,9 @@ function loadProject(rootDir) {
 const DEFAULT_REGISTRY = join(".nuxt", REGISTRY_FILE);
 /** Editors keep the linter running, so a project is reloaded when its inputs change. */
 const cache = /* @__PURE__ */ new Map();
-function findRoot(file) {
-	for (let dir = dirname(file);; dir = dirname(dir)) {
+/** The nearest directory from `startDir` up that holds a registry. */
+function findProjectRoot(startDir) {
+	for (let dir = startDir;; dir = dirname(dir)) {
 		if (existsSync(join(dir, DEFAULT_REGISTRY))) return dir;
 		if (dirname(dir) === dir) return null;
 	}
@@ -119,7 +61,7 @@ function tryLoadProject(rootDir) {
 }
 /** The Nuxt project a linted file belongs to, from its registry; Nuxt itself is never loaded. */
 function projectFor(file, root) {
-	const rootDir = root === void 0 ? findRoot(file) : resolve(root);
+	const rootDir = root === void 0 ? findProjectRoot(dirname(file)) : resolve(root);
 	if (rootDir === null) return {
 		ok: false,
 		message: `No ${DEFAULT_REGISTRY} above this file. Run "nuxi prepare", or set the rule's "root" option to the Nuxt project.`
@@ -137,6 +79,101 @@ function projectFor(file, root) {
 	return load;
 }
 //#endregion
+//#region src/eslint/stamp.ts
+function digest(file) {
+	return file !== null && existsSync(file) ? createHash("sha1").update(readFileSync(file)).digest("hex") : "";
+}
+/**
+* What layerscope's results depend on besides the linted file: the registry and the layer config.
+* ESLint's cache keys a result on the file and the ESLint config only, so this goes into the
+* config, which drops cached results when it changes. Content, not mtime: `nuxi prepare` rewrites
+* an unchanged registry.
+*/
+function projectStamp(cwd = process.cwd()) {
+	const root = findProjectRoot(cwd);
+	if (root === null) return "";
+	const parts = [join(root, DEFAULT_REGISTRY), findConfigFile(root)].map((file) => digest(file));
+	return createHash("sha1").update(parts.join(":")).digest("hex");
+}
+//#endregion
+//#region src/eslint/recommended.ts
+/** Built when `eslint.config.*` loads, so `--cache` sees the stamp of this run. */
+function createRecommended(plugin, cwd) {
+	return {
+		name: "nuxt-layerscope/recommended",
+		plugins: { layerscope: plugin },
+		settings: { layerscope: { stamp: projectStamp(cwd) } },
+		rules: {
+			"layerscope/layer-boundary": "error",
+			"layerscope/unresolved-reference": "warn"
+		}
+	};
+}
+//#endregion
+//#region src/eslint/lint-file.ts
+/**
+* Both rules lint the same text, so the last result per file is reused. A reloaded project
+* (registry or config changed) is another object, so results from before it are not reused.
+*/
+const lastLint = /* @__PURE__ */ new Map();
+/**
+* oxlint passes only the `<script>` of a `.vue` file to JS plugins, while the template matters
+* too; the saved file is read instead.
+*/
+function fullSource(file, text) {
+	return file.endsWith(".vue") && !/<(?:script|template)[\s>]/u.test(text) ? readFileSync(file, "utf8") : text;
+}
+/** Lints the text the editor holds, which may differ from the file on disk. */
+function lintFile(file, text, project) {
+	const source = fullSource(file, text);
+	const cached = lastLint.get(file);
+	if (cached?.project === project && cached.source === source) return cached.lint;
+	const layer = project.env.ownerOf(file);
+	let lint = {
+		source,
+		boundary: [],
+		unresolved: []
+	};
+	if (layer !== null && isCheckedFile(file, layer, project.config.ignore ?? [])) {
+		const analysis = new FileAnalysis(file, source, layer, project.env).run(scanFile(source, file));
+		lint = {
+			source,
+			boundary: boundaryFindings(analysis.edges, project.config),
+			unresolved: analysis.unresolved
+		};
+	}
+	lastLint.set(file, {
+		project,
+		source,
+		lint
+	});
+	return lint;
+}
+//#endregion
+//#region src/eslint/location.ts
+/**
+* Maps a finding from the full file into the text the linter passed. ESLint passes the full
+* file; oxlint passes only a `.vue` file's `<script>`, where template findings have no position.
+*/
+function reportLocation(finding, source, text) {
+	if (source === text) return {
+		line: finding.line,
+		column: finding.column,
+		outside: false
+	};
+	const base = source.indexOf(text);
+	const offset = offsetAt(source, finding) - base;
+	if (base === -1 || offset < 0 || offset > text.length) return {
+		line: 1,
+		column: 1,
+		outside: true
+	};
+	return {
+		...lineColumn(text, offset),
+		outside: false
+	};
+}
+//#endregion
 //#region src/eslint/rules.ts
 const OPTIONS_SCHEMA = [{
 	type: "object",
@@ -201,13 +238,6 @@ const plugin = {
 	rules,
 	configs: {}
 };
-plugin.configs.recommended = {
-	name: "nuxt-layerscope/recommended",
-	plugins: { layerscope: plugin },
-	rules: {
-		"layerscope/layer-boundary": "error",
-		"layerscope/unresolved-reference": "warn"
-	}
-};
+plugin.configs.recommended = createRecommended(plugin);
 //#endregion
 export { plugin as default };