nuxt-layerscope 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+Initial release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hamed Niroomand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,289 @@
+# nuxt-layerscope
+
+Layer boundary checks for Nuxt 3 and 4 apps that also see auto-imports.
+
+Boundary tools usually read `import` statements only, so a component in `admin` that calls an
+auto-imported composable from `web` goes unnoticed. layerscope reads the registry Nuxt resolves
+(components, app and server auto-imports, layers), resolves every auto-imported identifier,
+component tag and explicit import to its source file and layer, and checks the result against
+your rules.
+
+```text
+layers/admin/app/components/AdminPanel.vue
+  2:14    error  Auto-import "useCart" crosses from layer "admin" into "web"  layer-boundary
+                 useCart → layers/web/app/composables/useCart.ts
+                 allowed for "admin": shared, auth
+```
+
+## Usage
+
+```bash
+npx nuxi module add nuxt-layerscope --dev   # installs it and adds it to `modules`
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['nuxt-layerscope'],
+});
+```
+
+```bash
+npx nuxi prepare
+npx layerscope check                 # or: npx layerscope check --prepare
+```
+
+The module records what Nuxt resolves during `nuxi prepare`, `dev` and `build` into
+`.nuxt/layerscope/registry.json`. Without it, layerscope falls back to the generated `.d.ts`
+files, which gives the same boundary findings but cannot see overridden components (see
+[`shadowed-component`](#rules)). `npx nuxt-layerscope check` works without installing anything.
+Set `layerscope: { enabled: false }` in `nuxt.config` to turn the module off.
+
+| Option              | Description                                                              |
+| ------------------- | ------------------------------------------------------------------------ |
+| `[root]`            | Nuxt project root (default: current dir)                                 |
+| `--format <format>` | `text` (default), `github` or `json`                                     |
+| `--config <file>`   | Config path (default: `layerscope.config.ts`)                            |
+| `--prepare`         | Run `nuxi prepare` first                                                 |
+| `--baseline <file>` | Accepted findings, relative to the root (`layerscope-baseline.json`)     |
+| `--update-baseline` | Write every current finding to the baseline file and exit `0`            |
+| `--source <source>` | `auto` (default: registry when present), `registry` or `types` (`.d.ts`) |
+| `--verbose`         | Print where symbols were read from (to stderr)                           |
+
+Exit codes: `0` clean, `1` rule errors, `2` config or input error. Notes, such as a rule that
+could not run, go to stderr so stdout stays machine-readable.
+
+`--format github` prints workflow commands, so findings show up inline on the pull request diff.
+JSON findings carry `target` (the file the symbol resolves to) and, for `layer-boundary`,
+`allowed`.
+
+### Baseline
+
+Turn the check on in a codebase that already has violations, then fix them over time:
+
+```bash
+npx layerscope check --update-baseline   # writes layerscope-baseline.json; commit it
+npx layerscope check                     # fails only on findings missing from the baseline
+```
+
+Entries are keyed by rule, file, symbol and target layer, not by line, so unrelated edits and
+moving a violation within its file keep the entry. Entries that no longer occur are listed as
+fixed (and as `::notice` annotations with `--format github`); run `--update-baseline` again to
+drop them, so the file only shrinks.
+
+### GitHub Action
+
+```yaml
+# .github/workflows/layerscope.yml
+on: pull_request
+jobs:
+  layerscope:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+      - run: npm ci
+      - run: npx nuxi prepare
+      - uses: hamedniroomand/nuxt-layerscope@main
+```
+
+It runs `layerscope check --format github`, so findings show up inline on the pull request. Inputs:
+`root` (default `.`), `config`, `prepare` (`true` runs `nuxi prepare` instead of the separate
+step), `baseline` (default `layerscope-baseline.json`) and `version` (used through `npx` when the
+project does not install `nuxt-layerscope`).
+
+### `layerscope why <symbol> [root]`
+
+Lists every file that uses a symbol, where the symbol resolves to and the layer path each use
+crosses. It accepts auto-imports, component names (`BaseButton`, `base-button` and
+`LazyBaseButton` are the same component) and import specifiers.
+
+```text
+$ npx layerscope why useCart
+useCart → layers/web/app/composables/useCart.ts (web)
+  layers/admin/app/components/AdminPanel.vue:2:14   admin → web   ✖ not allowed
+  layers/web/app/components/CartSummary.vue:3:14    web → web     ✔ same layer
+```
+
+Takes `--format text|json`, `--config`, `--prepare`, `--source` and `--verbose`. Exit codes: `0` when the symbol is used,
+`2` when no use is found.
+
+### `layerscope graph [root]`
+
+Prints the dependency graph between layers (`--by layer`, the default) or between files
+(`--by file`, grouped by layer). Edges that break the layer rules are drawn in red and labelled
+with how many references they carry. Packages are left out.
+
+```bash
+npx layerscope graph > layers.mmd                 # Mermaid, for docs and PR descriptions
+npx layerscope graph --by file --format dot | dot -Tsvg > files.svg
+```
+
+`--format mermaid` (default), `dot` or `json`. Always exits `0`.
+
+### `layerscope unused [root]`
+
+Lists components and auto-imports (composables, utils, server utils) that nothing references,
+per layer. Explicit imports of a file count as using everything it exports. When the project
+renders components chosen at runtime (`<component :is>` bound to a value, `resolveComponent(x)`),
+unused components are marked "possibly used at runtime". Layers installed as packages are not
+checked. `--format text` (default) or `json`. Always exits `0`.
+
+### Editor feedback: ESLint and oxlint
+
+`nuxt-layerscope/eslint` reports the same findings as `check` while you type. It reads the
+registry the module writes, so the module is required, and it never boots Nuxt.
+
+```js
+// eslint.config.js
+import layerscope from 'nuxt-layerscope/eslint';
+
+export default [
+  // ...your parsers (vue-eslint-parser for .vue files)
+  layerscope.configs.recommended,
+];
+```
+
+The rules are `layerscope/layer-boundary` and `layerscope/unresolved-reference`. Each takes an
+optional `{ root }` (the Nuxt project, relative to the working directory); by default the project
+is the nearest directory above the file with `.nuxt/layerscope/registry.json`. Set `root` for layers
+that live outside the app (for example a layer package in a monorepo).
+
+oxlint loads the same plugin through `jsPlugins`:
+
+```json
+{
+  "jsPlugins": [{ "name": "layerscope", "specifier": "nuxt-layerscope/eslint" }],
+  "rules": { "layerscope/layer-boundary": "error", "layerscope/unresolved-reference": "warn" }
+}
+```
+
+oxlint passes only the `<script>` of `.vue` files to plugins, so findings in a template are shown
+at the start of the script with their template line in the message.
+
+### Nuxt DevTools
+
+While `nuxi dev` runs, the module adds a **Layerscope** tab to Nuxt DevTools with the layers,
+what each may depend on and the current findings. File links open in your editor. The report is
+also served as JSON at `/__layerscope?format=json`. Turn it off with `layerscope: { devtools: false }`.
+
+## Config
+
+```ts
+// layerscope.config.ts
+import { defineConfig } from 'nuxt-layerscope';
+
+export default defineConfig({
+  layers: {
+    shared: { allow: [] },
+    auth: { allow: ['shared'] },
+    web: { allow: ['shared', 'auth'] },
+    admin: { allow: ['shared', 'auth'] },
+  },
+  rules: {
+    'layer-boundary': 'error',
+    'unresolved-reference': 'warn',
+    'shadowed-component': 'warn',
+  },
+});
+```
+
+Or put the same options under `layerscope` in `nuxt.config`, next to `enabled` and `devtools`. The
+module records them on `nuxi prepare`, `dev` and `build`; use one place or the other, not both.
+
+- Layer names come from Nuxt: the folder name for `layers/<name>` and for `extends` entries, or
+  `$meta.name`. The project itself is `root`. Set `path` on an entry to name a layer explicitly,
+  or `source` (the `extends` string, such as `github:acme/console`) to name a remote layer.
+- A layer missing from `layers` is unrestricted. Edges within a layer are always allowed.
+- `ignore` adds globs to skip, and `globals` lists identifiers or components registered at runtime
+  (for example by a plugin) so they are not reported as unresolved.
+
+## Rules
+
+- `layer-boundary`: a file depends on a layer its own layer does not `allow`. This covers
+  auto-imported composables and utils, components (including `Lazy*`), Nitro server utils and
+  explicit imports (`#layers/...`, `~/...` and relative paths).
+- `unresolved-reference`: something could not be resolved, so layerscope will not call it safe.
+  Examples are an identifier that is neither a local binding, a known global nor an auto-import;
+  a component missing from `components.d.ts`; an import path that does not exist; or
+  `<component :is>` bound to a runtime value.
+- `shadowed-component` (warning): two layers register a component with the same name and Nuxt
+  uses the higher-priority one. The overridden component is reported with both paths, so
+  accidental overrides are visible. Needs the module; with the `.d.ts` fallback the rule reports
+  nothing and says so on stderr.
+
+## How it works
+
+1. Layers come from the project's own `@nuxt/kit`, which every Nuxt install already has:
+   `loadNuxtConfig` for the list and names, `getLayerDirectories` for each layer's `srcDir`,
+   `serverDir` and `shared` dir. Without kit, layers can be declared with `path` in the config.
+2. Each file belongs to the layer with the longest matching root, compared as real paths so
+   pnpm symlinks do not matter. Layers installed from npm or a remote source live under
+   `node_modules` and still own their files, so boundaries apply to them; their own code is
+   resolved but not checked. Anything outside every layer is external. Files under a layer's
+   server dir use the Nitro symbol table, and files under its shared dir use the shared one.
+3. Scripts are parsed with `oxc-parser` and scope-tracked, so a local `useCart` shadows the
+   auto-imported one. Templates are compiled with `@vue/compiler-sfc`, and the render function's
+   `resolveComponent("X")` calls and `_ctx.x` reads show which components and identifiers Nuxt
+   would auto-import.
+4. With the module, symbols come from `.nuxt/layerscope/registry.json`, recorded from Nuxt's own
+   hooks: `components:dirs` and `components:extend` (every scanned component, including
+   overridden ones), `imports:context` (app auto-imports), Nitro's unimport context (server
+   auto-imports) and `getLayerDirectories()` (layers in priority order). The file has a versioned
+   schema; a registry from an incompatible release is ignored with a note.
+5. Without the module, components come from `.nuxt/components.d.ts` (or
+   `.nuxt/types/components.d.ts`) and auto-imports from `.nuxt/types/*imports.d.ts`. On Nuxt 3,
+   which writes no `shared-imports.d.ts`, the shared context gets the imports app and server
+   have in common, as Nuxt 4 does.
+6. Generated files that point at deleted files, or that miss a component, are treated as stale
+   (exit `2`). With the registry every dir Nuxt scanned is compared, including custom component
+   dirs; without it only the default `components/` dirs are.
+
+The JSON report (`--format json`) is versioned and deterministic: the same input produces the same
+bytes.
+
+## Package entry points
+
+| Import                   | Contents                                                                                       |
+| ------------------------ | ---------------------------------------------------------------------------------------------- |
+| `nuxt-layerscope`        | The Nuxt module (default export), `defineConfig` and the types. Light enough for Nuxt startup. |
+| `nuxt-layerscope/api`    | `analyze`, `formatResult`, `createBaseline` and the report and registry constants.             |
+| `nuxt-layerscope/eslint` | ESLint and oxlint plugin with `layer-boundary` and `unresolved-reference` rules.               |
+| `layerscope` (bin)       | The CLI.                                                                                       |
+
+```ts
+import { analyze, formatResult } from 'nuxt-layerscope/api';
+
+const result = await analyze({ rootDir: 'apps/shop' });
+process.stdout.write(formatResult(result, 'text'));
+```
+
+## Compared with other tools
+
+Other tools cover parts of this. layerscope is narrower: it resolves symbols exactly the way Nuxt
+does, understands Nuxt layer semantics, and is built to fail a CI job.
+
+|                                               | layerscope                             | [eslint-plugin-nuxt-layers] | [nuxt-fsd]      | [Archora]                     | [Nuxt DevTools]     |
+| --------------------------------------------- | -------------------------------------- | --------------------------- | --------------- | ----------------------------- | ------------------- |
+| Boundary rules on explicit imports            | ✓                                      | ✓                           | ✓ (FSD layers)  | ✓                             | –                   |
+| Boundary rules on auto-imports and components | ✓                                      | –                           | –               | ✓                             | –                   |
+| Resolves symbols from                         | Nuxt's generated types and `@nuxt/kit` | import paths                | its own aliases | its own analyzer              | the running app     |
+| Knows Nuxt layers (`extends`, `layers/`, npm) | ✓                                      | folder layout               | –               | not Nuxt-specific             | shows them          |
+| CI gate                                       | exit codes, PR annotations             | via ESLint                  | –               | exit codes, thresholds        | –                   |
+| Scope                                         | Nuxt layer boundaries                  | import boundaries           | FSD structure   | general architecture analyzer | dev-time inspection |
+
+- **eslint-plugin-nuxt-layers** checks `import` statements against a layer map. It works inside
+  ESLint and the editor, but auto-imports have no import statement to check.
+- **nuxt-fsd** sets up Feature-Sliced Design in Nuxt and blocks cross-imports, but its own README
+  notes that auto-imports do not respect those rules.
+- **Archora** (`@archora/cli`) is a general frontend architecture analyzer that also resolves Nuxt
+  auto-imported composables, alongside cycles, churn and bundle analysis. Pick it for a broad
+  architecture report; pick layerscope for exact Nuxt layer boundaries as a CI gate.
+- **Nuxt DevTools** shows components and auto-imports of a running app, but does not enforce rules.
+
+[eslint-plugin-nuxt-layers]: https://github.com/alexanderop/eslint-plugin-nuxt-layers
+[nuxt-fsd]: https://github.com/aabounegm/nuxt-fsd
+[Archora]: https://github.com/archora-dev/archora
+[Nuxt DevTools]: https://devtools.nuxt.com

package/dist/analyze-DS51xy6X.mjs

@@ -0,0 +1,337 @@
+import { c as realPath, d as effectiveConfig, g as LayerscopeError, h as ruleSeverity, m as isRuleName, s as readJson } from "./layer-factory-xZmIAPrA.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-Bkq_69x4.mjs";
+import { basename, extname, join, relative, resolve } from "pathe";
+import { existsSync, writeFileSync } 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) {
+	return compareStrings(a.file, b.file) || a.line - b.line || a.column - b.column || compareStrings(a.rule ?? a.kind ?? "", b.rule ?? b.kind ?? "") || compareStrings(a.symbol, b.symbol);
+}
+//#endregion
+//#region src/rules/shadowed-component.ts
+const SHADOWED_NEEDS_REGISTRY = "shadowed-component needs the full component registry: add \"nuxt-layerscope\" to \"modules\" in nuxt.config. The generated .d.ts files list only the winning component, so the rule reported nothing.";
+/** Components a higher-priority layer replaces, so accidental overrides are visible. */
+function shadowedFindings(registry, ownerOf, config) {
+	const severity = ruleSeverity(config, "shadowed-component");
+	if (severity === "off") return [];
+	return registry.shadowedComponents.flatMap((component) => {
+		const file = realPath(component.file);
+		const target = realPath(component.shadowedBy);
+		const from = ownerOf(file);
+		if (from === null) return [];
+		const to = ownerOf(target);
+		const winner = to === null ? target : `layer "${to.name}"`;
+		return [{
+			rule: "shadowed-component",
+			severity,
+			file,
+			line: 1,
+			column: 1,
+			symbol: component.name,
+			fromLayer: from.name,
+			toLayer: to?.name ?? null,
+			target,
+			message: `Component <${component.name}> of layer "${from.name}" is overridden by ${winner}`
+		}];
+	});
+}
+//#endregion
+//#region src/rules/index.ts
+/** Every rule's findings in report order, and notes on rules that could not run. */
+function runRules(input) {
+	const { registry, config } = input;
+	const notes = [];
+	if (registry === null && ruleSeverity(config, "shadowed-component") !== "off") notes.push(SHADOWED_NEEDS_REGISTRY);
+	return {
+		findings: [
+			...input.unresolved,
+			...boundaryFindings(input.edges, config),
+			...registry === null ? [] : shadowedFindings(registry, input.ownerOf, config)
+		].toSorted(compareByPosition),
+		notes
+	};
+}
+//#endregion
+//#region src/analyze/freshness.ts
+const RERUN_HINT = "Run \"nuxi prepare\" again, or pass --prepare.";
+const COMPONENT_SUFFIX = /(?:\.(?:client|server))?(?:\.global|\.island)*$/u;
+function allTargets(table) {
+	return [...table.components.values(), ...Object.values(table.imports).flatMap((map) => Array.from(map.values()))];
+}
+function assertNoDeletedTargets(targets) {
+	const deleted = targets.find((target) => target.file !== null && !existsSync(target.file));
+	if (deleted !== void 0 && deleted.file !== null) throw new LayerscopeError(`Generated types reference ${deleted.file}, which no longer exists. ${RERUN_HINT}`);
+}
+async function defaultComponentFiles(layers) {
+	const dirs = layers.filter((layer) => layer.defaultComponents).map((layer) => join(layer.srcDir, "components")).filter((dir) => existsSync(dir));
+	if (dirs.length === 0) return [];
+	const patterns = dirs.map((dir) => join(escapePath(dir), "**/*.vue"));
+	const ignore = dirs.flatMap((dir) => [join(escapePath(dir), "islands/**"), join(escapePath(dir), "**/*.island.vue")]);
+	return (await glob(patterns, {
+		absolute: true,
+		ignore
+	})).toSorted();
+}
+/**
+* The `.d.ts` files list only the winner of a layer override, so a file whose name matches a
+* registered component is taken as overridden rather than new.
+*/
+function isRegisteredName(file, names) {
+	const name = pascalCase(basename(file, extname(file)).replace(COMPONENT_SUFFIX, ""));
+	return names.some((registered) => registered.endsWith(name));
+}
+/**
+* Stale generated types either point at deleted files or miss new components. File mtimes are
+* not used: Nuxt skips rewriting unchanged templates, so they would report false staleness.
+* Without the registry only the default `components/` dirs are known.
+*/
+async function assertFresh(table, layers) {
+	const targets = allTargets(table);
+	assertNoDeletedTargets(targets);
+	const known = new Set(targets.map((target) => target.file));
+	const names = [...table.components.keys()];
+	const unknown = (await defaultComponentFiles(layers)).find((file) => !known.has(file) && !isRegisteredName(file, names));
+	if (unknown !== void 0) throw new LayerscopeError(`${unknown} is missing from components.d.ts. ${RERUN_HINT}`);
+}
+/** With the registry, every dir Nuxt scanned (`components:dirs`) is compared, not just the default. */
+async function assertRegistryFresh(table, registry) {
+	assertNoDeletedTargets(allTargets(table));
+	for (const dir of registry.componentDirs) {
+		if (dir.path.includes("/node_modules/") || !existsSync(dir.path)) continue;
+		const recorded = new Set(dir.files);
+		const added = (await globComponents(dir.path, dir.pattern, dir.ignore)).find((file) => !recorded.has(file));
+		if (added !== void 0) throw new LayerscopeError(`${added} is missing from the layerscope registry. ${RERUN_HINT}`);
+	}
+}
+//#endregion
+//#region src/analyze/layers.ts
+/**
+* A layer's `srcDir` leaks into a project that does not set its own, so Nuxt then looks for the
+* project's app in a dir that does not exist while `app/` is ignored.
+*/
+function layerNotes(layers, rootDir) {
+	return layers.flatMap((layer) => {
+		const appDir = join(layer.root, "app");
+		if (existsSync(layer.srcDir) || !existsSync(appDir)) return [];
+		const srcDir = relative(rootDir, layer.srcDir) || ".";
+		return [`Layer "${layer.name}" has srcDir ${srcDir}, which does not exist, so Nuxt ignores ${relative(rootDir, appDir)}. An extended layer's srcDir may have been merged in; set srcDir in its nuxt.config.`];
+	});
+}
+/** Layers in priority order, with the lookup of which layer owns a file. */
+async function loadLayers(rootDir, config, registryLayers) {
+	const layers = await resolveLayers(rootDir, config, registryLayers);
+	return {
+		layers,
+		ownerOf: createOwnerLookup(layers),
+		notes: layerNotes(layers, rootDir)
+	};
+}
+//#endregion
+//#region src/analyze/symbols.ts
+/** The module's registry when present (or required), else the generated `.d.ts` files. */
+function loadSymbols(buildDir, source) {
+	const read = source === "types" ? null : readRegistry(buildDir);
+	if (read?.kind === "ok") {
+		const { file, registry } = read;
+		return {
+			source: "registry",
+			sourceFile: file,
+			registry,
+			table: tableFromRegistry(registry, buildDir),
+			notes: []
+		};
+	}
+	const notes = [];
+	if (read?.kind === "incompatible") {
+		const found = JSON.stringify(read.version);
+		const message = `${read.file} has schema version ${found}, which this layerscope does not read.`;
+		if (source === "registry") throw new LayerscopeError(`${message} Update nuxt-layerscope in the project.`);
+		notes.push(`${message} Falling back to the generated .d.ts files.`);
+	} else if (read !== null && source === "registry") throw new LayerscopeError(`${read.file} not found. Add "nuxt-layerscope" to "modules" in nuxt.config and run "nuxi prepare".`);
+	const table = loadSymbolTable(buildDir);
+	return {
+		source: "types",
+		sourceFile: join(buildDir, "types"),
+		registry: null,
+		table,
+		notes
+	};
+}
+//#endregion
+//#region src/analyze/environment.ts
+/** Read even when symbols come from the `.d.ts` files, so `nuxt.config` options still apply. */
+function recordedConfig(buildDir, registry) {
+	if (registry !== null) return registry.config;
+	const read = readRegistry(buildDir);
+	return read.kind === "ok" ? read.registry.config : void 0;
+}
+/** Everything the analysis reads from Nuxt: layers, the symbol registry and aliases. */
+async function loadEnvironment(options) {
+	const { rootDir, buildDir } = options;
+	const { registry, table, ...symbols } = loadSymbols(buildDir, options.source);
+	const config = effectiveConfig(options.config, recordedConfig(buildDir, registry));
+	const { layers, ownerOf, notes } = await loadLayers(rootDir, config, registry?.layers);
+	await (registry === null ? assertFresh(table, layers) : assertRegistryFresh(table, registry));
+	return {
+		...symbols,
+		config,
+		notes: [...symbols.notes, ...notes],
+		registry,
+		layers,
+		env: createAnalysisEnv(table, ownerOf, buildDir, config)
+	};
+}
+//#endregion
+//#region src/analyze/prepare.ts
+function prepareNuxt(rootDir) {
+	if (spawnSync("npx", [
+		"--no-install",
+		"nuxi",
+		"prepare"
+	], {
+		cwd: rootDir,
+		stdio: [
+			"ignore",
+			2,
+			2
+		]
+	}).status !== 0) throw new LayerscopeError(`"nuxi prepare" failed in ${rootDir}`);
+}
+//#endregion
+//#region src/analyze/index.ts
+async function analyze(options = {}) {
+	const rootDir = resolve(options.rootDir ?? process.cwd());
+	const fileConfig = options.config ?? await loadConfig(rootDir, options.configFile);
+	const buildDir = resolve(rootDir, fileConfig.buildDir ?? ".nuxt");
+	if (options.prepare === true) prepareNuxt(rootDir);
+	const environment = await loadEnvironment({
+		rootDir,
+		buildDir,
+		config: fileConfig,
+		source: options.source ?? "auto"
+	});
+	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 edges = analyses.flatMap((analysis) => analysis.edges).toSorted(compareByPosition);
+	const { findings, notes } = runRules({
+		edges,
+		unresolved: analyses.flatMap((analysis) => analysis.unresolved),
+		registry,
+		ownerOf: env.ownerOf,
+		config
+	});
+	const result = {
+		rootDir,
+		config,
+		source: environment.source,
+		sourceFile: environment.sourceFile,
+		layers,
+		files: [...files.keys()],
+		edges,
+		findings,
+		notes: [...environment.notes, ...notes],
+		symbols: env.table,
+		dynamicComponentFiles: analyses.filter((analysis) => analysis.hasDynamicComponent).map((analysis) => analysis.file)
+	};
+	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 };

package/dist/analyze-YePAJEVS.mjs

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