nuxt-layerscope 0.1.0

package/dist/api.d.mts

@@ -0,0 +1,148 @@
+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";
+//#region src/analyze/index.d.ts
+interface AnalyzeOptions {
+  /** Defaults to `process.cwd()`. */
+  rootDir?: string;
+  /** Defaults to `layerscope.config.*` in the root. */
+  configFile?: string;
+  /** Used instead of loading a config file. */
+  config?: LayerscopeConfig;
+  /** Run `nuxi prepare` before reading generated files. */
+  prepare?: boolean;
+  /** Where symbols come from. Defaults to `auto`: the registry when present, else `.d.ts`. */
+  source?: SourceOption;
+  /**
+   * Baseline file, relative to the root. Findings it lists are moved to `baseline.suppressed`.
+   * Ignored when the file does not exist.
+   */
+  baseline?: string;
+}
+export declare function analyze(options?: AnalyzeOptions): Promise<AnalyzeResult>;
+//#endregion
+//#region src/baseline/index.d.ts
+export declare const BASELINE_FILE = "layerscope-baseline.json";
+/** Bumped on breaking changes to the baseline file. */
+export declare const BASELINE_VERSION = 1;
+interface Baseline {
+  version: typeof BASELINE_VERSION;
+  entries: BaselineEntry[];
+}
+export declare function createBaseline(findings: Finding[], rootDir: string): Baseline;
+//#endregion
+//#region src/errors.d.ts
+/** A config or input problem; the CLI exits with code 2. */
+export declare class LayerscopeError extends Error {
+  name: string;
+}
+//#endregion
+//#region src/rules/edge-status.d.ts
+type EdgeStatus = 'same-layer' | 'external' | 'unrestricted' | 'allowed' | 'not-allowed';
+//#endregion
+//#region src/graph/index.d.ts
+declare const GRAPH_LEVELS: readonly ['layer', 'file'];
+type GraphLevel = (typeof GRAPH_LEVELS)[number];
+interface GraphNode {
+  id: string;
+  /** Owning layer; for layer graphs the node's own name. */
+  layer: string;
+}
+interface GraphEdge {
+  from: string;
+  to: string;
+  /** References behind this edge. */
+  count: number;
+  /** `not-allowed` when any reference behind it breaks the layer rules. */
+  status: EdgeStatus;
+}
+interface Graph {
+  level: GraphLevel;
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+/** Dependencies between layers or files inside layers; packages are left out. */
+export declare function buildGraph(result: AnalyzeResult, config: LayerscopeConfig, level: GraphLevel): Graph;
+//#endregion
+//#region src/registry/schema.d.ts
+/** Bumped on breaking changes to `registry.json`; readers fall back to the `.d.ts` files. */
+export declare const REGISTRY_VERSION = 1;
+/** Relative to the Nuxt build dir. */
+export declare const REGISTRY_FILE = "layerscope/registry.json";
+type ComponentMode = 'all' | 'client' | 'server';
+interface RegistryComponent {
+  /** PascalCase name, without the `Lazy` prefix. */
+  name: string;
+  /** Absolute path, or a bare module specifier for virtual components. */
+  file: string;
+  mode: ComponentMode;
+  island: boolean;
+  priority: number;
+}
+/** A component that lost to a higher-priority one with the same name. */
+interface ShadowedComponent extends RegistryComponent {
+  /** File of the component Nuxt registered instead. */
+  shadowedBy: string;
+}
+interface RegistryComponentDir {
+  path: string;
+  /** Glob Nuxt scans the dir with, relative to `path`. */
+  pattern: string | string[];
+  ignore: string[];
+  /** Files matched when the registry was written, for the stale check. */
+  files: string[];
+}
+interface RegistryImport {
+  /** Name the symbol is auto-imported as. */
+  name: string;
+  /** Absolute path once aliases are resolved, or a bare module specifier. */
+  from: string;
+}
+interface Registry {
+  version: typeof REGISTRY_VERSION;
+  generator: {
+    name: string;
+    version: string;
+    nuxt: string;
+  };
+  /** Highest priority first, as Nuxt orders `_layers`. */
+  layers: Layer[];
+  components: RegistryComponent[];
+  shadowedComponents: ShadowedComponent[];
+  componentDirs: RegistryComponentDir[];
+  imports: Record<Context, RegistryImport[]>;
+  /** The `layerscope` key of `nuxt.config`, when it sets layers or rules. Added in 0.1.0. */
+  config?: ProjectConfig;
+}
+//#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;
+//#endregion
+//#region src/report/json.d.ts
+/** Bumped on breaking changes to the JSON report shape. */
+export declare const JSON_REPORT_VERSION = 1;
+//#endregion
+//#region src/unused/index.d.ts
+type UnusedKind = 'component' | 'auto-import';
+interface UnusedSymbol {
+  name: string;
+  kind: UnusedKind;
+  /** Auto-import context; `null` for components. */
+  context: Context | null;
+  file: string;
+  layer: string;
+  /**
+   * The project renders components chosen at runtime, so a component may still be used
+   * without any static reference.
+   */
+  possiblyUsed: boolean;
+}
+/**
+ * Components and auto-imports registered by the project's own layers that nothing references.
+ * Layers installed as packages are not checked, so their symbols are never reported.
+ */
+export declare function findUnused(result: AnalyzeResult): UnusedSymbol[];
+//#endregion
+export { type AnalyzeOptions, type AnalyzeResult, type Baseline, type BaselineEntry, type BaselineResult, type Context, type Edge, type Finding, type Graph, type GraphEdge, type GraphLevel, type GraphNode, type Layer, type LayerRule, type LayerscopeConfig, type OutputFormat, type Reference, type ReferenceKind, type Registry, type ResolutionSource, type RuleName, type Severity, type SourceOption, type UnusedSymbol, defineConfig };

package/dist/api.mjs

@@ -0,0 +1,6 @@
+import { g as LayerscopeError, l as REGISTRY_FILE, u as REGISTRY_VERSION } from "./layer-factory-xZmIAPrA.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-DS51xy6X.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-Dxep1p6u.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.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/bin.mjs

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+import { g as LayerscopeError } from "./layer-factory-xZmIAPrA.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-DS51xy6X.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-Dxep1p6u.mjs";
+import { relative, resolve } from "pathe";
+import { cac } from "cac";
+//#region src/commands/shared.ts
+const SOURCE_OPTIONS = [
+	"auto",
+	"registry",
+	"types"
+];
+function withCommonOptions(command) {
+	return command.option("--config <file>", "Path to layerscope.config.ts").option("--prepare", "Run \"nuxi prepare\" before checking").option("--source <source>", `Symbol source: ${SOURCE_OPTIONS.join(", ")}`, { default: "auto" }).option("--verbose", "Print where symbols were read from");
+}
+function toSource(value) {
+	const source = SOURCE_OPTIONS.find((option) => option === 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. */
+function writeNotes(result, verbose) {
+	const lines = result.notes.map((note) => `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)})`);
+	}
+	if (lines.length > 0) process.stderr.write(`${lines.join("\n")}\n`);
+}
+//#endregion
+//#region src/commands/check.ts
+async function updateBaseline(rootDir, flags) {
+	const result = await analyze({
+		rootDir,
+		configFile: flags.config,
+		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`);
+	return 0;
+}
+async function check(root, flags) {
+	const { format } = flags;
+	if (!isOutputFormat(format)) throw new LayerscopeError(`Unknown format "${format}". Use ${OUTPUT_FORMATS.join(", ")}.`);
+	const rootDir = resolve(root ?? process.cwd());
+	if (flags.updateBaseline === true) return updateBaseline(rootDir, flags);
+	const result = await analyze({
+		rootDir,
+		configFile: flags.config,
+		prepare: flags.prepare,
+		source: toSource(flags.source),
+		baseline: flags.baseline
+	});
+	writeNotes(result, flags.verbose === true);
+	process.stdout.write(formatResult(result, format));
+	return result.findings.some((finding) => finding.severity === "error") ? 1 : 0;
+}
+function registerCheck(cli) {
+	withCommonOptions(cli.command("check [root]", "Check layer boundaries, including auto-imports").option("--format <format>", `Output format: ${OUTPUT_FORMATS.join(", ")}`, { default: "text" }).option("--baseline <file>", "Findings to accept, relative to the root", { default: BASELINE_FILE }).option("--update-baseline", "Write every current finding to the baseline file")).action(check);
+}
+//#endregion
+//#region src/report/graph/dot.ts
+function quote(text) {
+	return `"${text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function edgeLine$1(edge) {
+	const attributes = [...edge.count > 1 ? [`label=${edge.count}`] : [], ...edge.status === "not-allowed" ? ["color=red", "fontcolor=red"] : []];
+	const suffix = attributes.length > 0 ? ` [${attributes.join(", ")}]` : "";
+	return `  ${quote(edge.from)} -> ${quote(edge.to)}${suffix};`;
+}
+function nodeLines$1(graph) {
+	if (graph.level === "layer") return graph.nodes.map((node) => `  ${quote(node.id)};`);
+	const lines = [];
+	for (const [index, [layer, nodes]] of [...Map.groupBy(graph.nodes, (node) => node.layer)].entries()) lines.push(`  subgraph cluster_${index} {`, `    label=${quote(layer)};`, ...nodes.map((node) => `    ${quote(node.id)};`), "  }");
+	return lines;
+}
+/** Graphviz DOT; edges that break the layer rules are red. */
+function formatGraphDot(graph) {
+	return `${[
+		"digraph layerscope {",
+		"  rankdir=LR;",
+		...nodeLines$1(graph),
+		...graph.edges.map((edge) => edgeLine$1(edge)),
+		"}"
+	].join("\n")}\n`;
+}
+//#endregion
+//#region src/report/graph/json.ts
+function formatGraphJson(graph) {
+	return `${JSON.stringify({
+		version: 1,
+		...graph
+	}, null, 2)}\n`;
+}
+//#endregion
+//#region src/report/graph/mermaid.ts
+const VIOLATION_STYLE = "stroke:#d73a49,stroke-width:2px";
+function label(text) {
+	return `"${text.replaceAll("\"", "#quot;")}"`;
+}
+function edgeLine(edge, ids) {
+	const arrow = edge.count > 1 ? `-- ${edge.count} -->` : "-->";
+	return `  ${ids.get(edge.from)} ${arrow} ${ids.get(edge.to)}`;
+}
+function nodeLines(graph, ids) {
+	if (graph.level === "layer") return graph.nodes.map((node) => `  ${ids.get(node.id)}[${label(node.id)}]`);
+	const lines = [];
+	for (const [index, [layer, nodes]] of [...Map.groupBy(graph.nodes, (node) => node.layer)].entries()) lines.push(`  subgraph layer${index}[${label(layer)}]`, ...nodes.map((node) => `    ${ids.get(node.id)}[${label(node.id)}]`), "  end");
+	return lines;
+}
+/** A Mermaid flowchart; edges that break the layer rules are drawn in red. */
+function formatGraphMermaid(graph) {
+	const ids = new Map(graph.nodes.map((node, index) => [node.id, `n${index}`]));
+	const violations = graph.edges.flatMap((edge, index) => edge.status === "not-allowed" ? [index] : []);
+	const lines = [
+		"flowchart LR",
+		...nodeLines(graph, ids),
+		...graph.edges.map((edge) => edgeLine(edge, ids))
+	];
+	if (violations.length > 0) lines.push(`  linkStyle ${violations.join(",")} ${VIOLATION_STYLE}`);
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+//#region src/report/graph/index.ts
+const GRAPH_FORMATS = [
+	"mermaid",
+	"dot",
+	"json"
+];
+const formatters = {
+	mermaid: formatGraphMermaid,
+	dot: formatGraphDot,
+	json: formatGraphJson
+};
+function isGraphFormat(value) {
+	return Object.hasOwn(formatters, value);
+}
+function formatGraph(graph, format) {
+	return formatters[format](graph);
+}
+//#endregion
+//#region src/commands/graph.ts
+function toLevel(value) {
+	const level = GRAPH_LEVELS.find((option) => option === value);
+	if (level === void 0) throw new LayerscopeError(`Unknown level "${value}". Use ${GRAPH_LEVELS.join(", ")}.`);
+	return level;
+}
+async function graph(root, flags) {
+	const { format } = flags;
+	if (!isGraphFormat(format)) throw new LayerscopeError(`Unknown format "${format}". Use ${GRAPH_FORMATS.join(", ")}.`);
+	const level = toLevel(flags.by);
+	const rootDir = resolve(root ?? process.cwd());
+	const result = await analyze({
+		rootDir,
+		configFile: flags.config,
+		prepare: flags.prepare,
+		source: toSource(flags.source)
+	});
+	writeNotes(result, flags.verbose === true);
+	process.stdout.write(formatGraph(buildGraph(result, result.config, level), format));
+	return 0;
+}
+function registerGraph(cli) {
+	withCommonOptions(cli.command("graph [root]", "Print the dependency graph between layers or files").option("--format <format>", `Output format: ${GRAPH_FORMATS.join(", ")}`, { default: "mermaid" }).option("--by <level>", `Graph level: ${GRAPH_LEVELS.join(", ")}`, { default: "layer" })).action(graph);
+}
+//#endregion
+//#region src/report/unused.ts
+const UNUSED_FORMATS = ["text", "json"];
+function isUnusedFormat(value) {
+	return UNUSED_FORMATS.includes(value);
+}
+function describe(symbol) {
+	if (symbol.kind === "component") return symbol.possiblyUsed ? "component (possibly used at runtime)" : "component";
+	return `auto-import (${symbol.context ?? "app"})`;
+}
+function formatUnusedText(unused, cwd) {
+	if (unused.length === 0) return "✔ Every component and auto-import is referenced\n";
+	const rows = unused.map((symbol) => ({
+		symbol,
+		file: relative(cwd, symbol.file)
+	}));
+	const nameWidth = Math.max(...rows.map((row) => row.symbol.name.length));
+	const fileWidth = Math.max(...rows.map((row) => row.file.length));
+	const byLayer = Map.groupBy(rows, (row) => row.symbol.layer);
+	const sections = [...byLayer].map(([layer, layerRows]) => [layer, ...layerRows.map(({ symbol, file }) => `  ${symbol.name.padEnd(nameWidth)}  ${file.padEnd(fileWidth)}  ${describe(symbol)}`)].join("\n"));
+	const footer = `${plural(unused.length, "unused symbol")} in ${plural(byLayer.size, "layer")}`;
+	return `${[...sections, footer].join("\n\n")}\n`;
+}
+function formatUnusedJson(unused, cwd) {
+	const report = {
+		version: 1,
+		unused: unused.map((symbol) => ({
+			...symbol,
+			file: relative(cwd, symbol.file)
+		}))
+	};
+	return `${JSON.stringify(report, null, 2)}\n`;
+}
+function formatUnused(unused, format, cwd = process.cwd()) {
+	return format === "json" ? formatUnusedJson(unused, cwd) : formatUnusedText(unused, cwd);
+}
+//#endregion
+//#region src/commands/unused.ts
+async function unused(root, flags) {
+	const { format } = flags;
+	if (!isUnusedFormat(format)) throw new LayerscopeError(`Unknown format "${format}". Use ${UNUSED_FORMATS.join(", ")}.`);
+	const result = await analyze({
+		rootDir: resolve(root ?? process.cwd()),
+		configFile: flags.config,
+		prepare: flags.prepare,
+		source: toSource(flags.source)
+	});
+	writeNotes(result, flags.verbose === true);
+	process.stdout.write(formatUnused(findUnused(result), format));
+	return 0;
+}
+function registerUnused(cli) {
+	withCommonOptions(cli.command("unused [root]", "List components and auto-imports nothing references").option("--format <format>", `Output format: ${UNUSED_FORMATS.join(", ")}`, { default: "text" })).action(unused);
+}
+//#endregion
+//#region src/report/why.ts
+const WHY_FORMATS = ["text", "json"];
+const STATUS_LABELS = {
+	"same-layer": "✔ same layer",
+	external: "✔ external",
+	unrestricted: "✔ unrestricted",
+	allowed: "✔ allowed",
+	"not-allowed": "✖ not allowed"
+};
+function isWhyFormat(value) {
+	return WHY_FORMATS.includes(value);
+}
+function describeTarget(target, cwd) {
+	if (target.file === null) return `${target.external ?? "unknown"} (external)`;
+	return `${relative(cwd, target.file)} (${target.layer ?? "no layer"})`;
+}
+function formatTargetText(target, cwd) {
+	const rows = target.uses.map(({ edge, status }) => ({
+		location: `${relative(cwd, edge.file)}:${edge.line}:${edge.column}`,
+		path: `${edge.fromLayer} → ${edge.toLayer ?? edge.external ?? "unknown"}`,
+		status: STATUS_LABELS[status]
+	}));
+	const locationWidth = Math.max(...rows.map((row) => row.location.length));
+	const pathWidth = Math.max(...rows.map((row) => row.path.length));
+	const lines = rows.map((row) => `  ${row.location.padEnd(locationWidth)}   ${row.path.padEnd(pathWidth)}   ${row.status}`);
+	return [`${target.symbol} → ${describeTarget(target, cwd)}`, ...lines].join("\n");
+}
+function formatWhyJson(query, targets, cwd) {
+	const report = {
+		version: 1,
+		symbol: query,
+		targets: targets.map((target) => ({
+			symbol: target.symbol,
+			file: target.file === null ? null : relative(cwd, target.file),
+			layer: target.layer,
+			external: target.external,
+			uses: target.uses.map(({ edge, status }) => ({
+				file: relative(cwd, edge.file),
+				line: edge.line,
+				column: edge.column,
+				kind: edge.kind,
+				symbol: edge.symbol,
+				fromLayer: edge.fromLayer,
+				toLayer: edge.toLayer,
+				status
+			}))
+		}))
+	};
+	return `${JSON.stringify(report, null, 2)}\n`;
+}
+function formatWhy(query, targets, format, cwd = process.cwd()) {
+	if (format === "json") return formatWhyJson(query, targets, cwd);
+	return `${targets.map((target) => formatTargetText(target, cwd)).join("\n\n")}\n`;
+}
+//#endregion
+//#region src/why/index.ts
+/** `LazyBaseButton` and `base-button` both name `BaseButton`. */
+function componentName(name) {
+	const pascal = pascalCase(name);
+	return /^Lazy[A-Z]/u.test(pascal) ? pascal.slice(4) : pascal;
+}
+/** The name an edge is known by: `#imports:useCart` is `useCart`. */
+function edgeName(edge) {
+	const match = /^#(?:imports|components):(.+)$/u.exec(edge.symbol);
+	return match === null ? edge.symbol : match[1];
+}
+function matches(edge, query) {
+	if (edge.symbol === query) return true;
+	const name = edgeName(edge);
+	if (name === query) return true;
+	return (edge.kind === "component" || edge.symbol.startsWith("#components:")) && componentName(name) === componentName(query);
+}
+/** Every use of a symbol (auto-import, component or import specifier), in report order. */
+function findUses(result, query, config) {
+	const targets = /* @__PURE__ */ new Map();
+	for (const edge of result.edges.filter((candidate) => matches(candidate, query))) {
+		const key = edge.to ?? `external:${edge.external}`;
+		let target = targets.get(key);
+		if (target === void 0) {
+			target = {
+				symbol: edge.kind === "component" ? componentName(query) : query,
+				file: edge.to,
+				layer: edge.toLayer,
+				external: edge.external,
+				uses: []
+			};
+			targets.set(key, target);
+		}
+		target.uses.push({
+			edge,
+			status: edgeStatus(edge, config)
+		});
+	}
+	return [...targets.values()];
+}
+//#endregion
+//#region src/commands/why.ts
+async function why(symbol, root, flags) {
+	const { format } = flags;
+	if (!isWhyFormat(format)) throw new LayerscopeError(`Unknown format "${format}". Use ${WHY_FORMATS.join(", ")}.`);
+	const rootDir = resolve(root ?? process.cwd());
+	const result = await analyze({
+		rootDir,
+		configFile: flags.config,
+		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.`);
+	process.stdout.write(formatWhy(symbol, targets, format));
+	return 0;
+}
+function registerWhy(cli) {
+	withCommonOptions(cli.command("why <symbol> [root]", "List every use of a symbol and the layers it crosses").option("--format <format>", `Output format: ${WHY_FORMATS.join(", ")}`, { default: "text" })).action(why);
+}
+//#endregion
+//#region src/cli.ts
+function createCli() {
+	const cli = cac("layerscope");
+	registerCheck(cli);
+	registerWhy(cli);
+	registerGraph(cli);
+	registerUnused(cli);
+	cli.help();
+	return cli;
+}
+/** Runs the CLI and resolves to its exit code. */
+async function run(argv = process.argv) {
+	const cli = createCli();
+	try {
+		cli.parse(argv, { run: false });
+		if (cli.matchedCommand === void 0) {
+			if (cli.options.help === true) return 0;
+			cli.outputHelp();
+			return 2;
+		}
+		return await cli.runMatchedCommand();
+	} catch (error) {
+		process.stderr.write(`layerscope: ${error.message}\n`);
+		return 2;
+	}
+}
+//#endregion
+//#region src/bin.ts
+process.exitCode = await run();
+//#endregion
+export {};

package/dist/component-files-DgOXNE6l.mjs

@@ -0,0 +1,12 @@
+import { glob } from "tinyglobby";
+//#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 { globComponents as t };

package/dist/define-DNRGLVG_.d.mts

@@ -0,0 +1,126 @@
+//#region src/nuxt/symbols.d.ts
+interface SymbolTarget {
+  /** Source file, when there is one; a layer that owns it wins over `module`. */
+  file: string | null;
+  /** Package or virtual module, used when no layer owns `file`. */
+  module: string | null;
+}
+type SymbolMap = Map<string, SymbolTarget>;
+interface SymbolTable {
+  imports: Record<Context, SymbolMap>;
+  components: SymbolMap;
+}
+//#endregion
+//#region src/types.d.ts
+type Severity = 'off' | 'warn' | 'error';
+type RuleName = 'layer-boundary' | 'unresolved-reference' | 'shadowed-component';
+/** The Nuxt auto-import context a source file runs in. */
+type Context = 'app' | 'server' | 'shared';
+interface Layer {
+  name: string;
+  root: string;
+  srcDir: string;
+  serverDir: string;
+  sharedDir: string;
+  /** Whether the layer uses Nuxt's default `<srcDir>/components` dir. */
+  defaultComponents: boolean;
+}
+type ReferenceKind = 'auto-import' | 'component' | 'import';
+interface Reference {
+  file: string;
+  line: number;
+  column: number;
+  kind: ReferenceKind;
+  /** Identifier, component name or import specifier. */
+  symbol: string;
+}
+interface Edge extends Reference {
+  fromLayer: string;
+  /** `null` when the target is outside every layer. */
+  to: string | null;
+  toLayer: string | null;
+  /** Package or virtual module name for targets outside every layer. */
+  external: string | null;
+}
+interface Finding {
+  rule: RuleName;
+  severity: Exclude<Severity, 'off'>;
+  file: string;
+  line: number;
+  column: number;
+  symbol: string;
+  fromLayer: string;
+  toLayer: string | null;
+  /** File the symbol resolves to, when known. */
+  target: string | null;
+  /** Layers `fromLayer` may depend on, for `layer-boundary` findings. */
+  allowed?: string[];
+  message: string;
+}
+interface LayerRule {
+  /** Layers this layer may depend on. Layers missing from config are unrestricted. */
+  allow?: string[];
+  /** Layer root relative to the project root; names a layer or declares it without @nuxt/kit. */
+  path?: string;
+  /** The `extends` source of a remote layer (`github:org/repo`); names the layer c12 cloned from it. */
+  source?: string;
+}
+interface LayerscopeConfig {
+  layers?: Record<string, LayerRule>;
+  rules?: Partial<Record<RuleName | 'unused-symbol', Severity>>;
+  /** Globs relative to each scanned dir. */
+  ignore?: string[];
+  /** Identifiers and component names never reported as unresolved. */
+  globals?: string[];
+  /** Relative to the project root. Defaults to `.nuxt`. */
+  buildDir?: string;
+}
+/**
+ * `registry`: `.nuxt/layerscope/registry.json`, written by the `nuxt-layerscope` Nuxt
+ * module. `types`: the generated `.d.ts` files, used when the module is not installed.
+ */
+type ResolutionSource = 'registry' | 'types';
+/** `auto` reads the registry when the Nuxt module wrote one, and the `.d.ts` files otherwise. */
+type SourceOption = ResolutionSource | 'auto';
+/** A finding counts by rule, file, symbol and target layer, never by line. */
+interface BaselineEntry {
+  rule: RuleName;
+  /** Relative to the project root. */
+  file: string;
+  symbol: string;
+  toLayer: string | null;
+  /** How often the key occurs; defaults to 1. */
+  count?: number;
+}
+interface BaselineResult {
+  file: string;
+  /** Findings present in the baseline, left out of `findings`. */
+  suppressed: Finding[];
+  /** Entries that no longer occur and can be removed with `--update-baseline`. */
+  removable: BaselineEntry[];
+}
+interface AnalyzeResult {
+  rootDir: string;
+  /** The config that applied: `layerscope.config.*` or the `layerscope` key of `nuxt.config`. */
+  config: LayerscopeConfig;
+  source: ResolutionSource;
+  /** File the symbols were read from. */
+  sourceFile: string;
+  layers: Layer[];
+  files: string[];
+  edges: Edge[];
+  findings: Finding[];
+  /** Things the user should know about the run, such as rules that could not run. */
+  notes: string[];
+  /** Every auto-import and component Nuxt registered, by context. */
+  symbols: SymbolTable;
+  /** Files rendering a component chosen at runtime (`<component :is>`, `resolveComponent(x)`). */
+  dynamicComponentFiles: string[];
+  /** Set when a baseline was applied; `findings` then holds only the new ones. */
+  baseline?: BaselineResult;
+}
+//#endregion
+//#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 };

package/dist/define-l62B9fVk.mjs

@@ -0,0 +1,6 @@
+//#region src/config/define.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { defineConfig as t };

package/dist/define.d.mts

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

package/dist/define.mjs

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