nuxt-layerscope 0.1.3 → 0.1.4

package/dist/owner-BA00V9VD.mjs

@@ -0,0 +1,451 @@
+import { E as LayerscopeError, S as validateConfig, T as LayerConfigError, _ as readJson, a as isClonedFrom, d as resolveFile, i as layerFromPath, n as deriveDirectories, o as REGISTRY_FILE, r as layerFromNuxt, t as ROOT_LAYER_NAME, u as packageName, v as realPath, w as ruleSeverity } from "./layer-factory-DVSf2Wj4.mjs";
+import { dirname, isAbsolute, join, resolve } from "pathe";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import globals from "globals";
+//#region src/config/load.ts
+const CONFIG_NAMES = [
+	"layerscope.config.ts",
+	"layerscope.config.mts",
+	"layerscope.config.js",
+	"layerscope.config.mjs"
+];
+/**
+* Config files import `defineConfig` from this package. Aliasing it to our own module lets
+* them load even when layerscope runs through npx without being a project dependency.
+*/
+function defineConfigModule() {
+	const candidates = ["./define.ts", "./define.mjs"].map((path) => fileURLToPath(new URL(path, import.meta.url)));
+	return candidates.find((path) => existsSync(path)) ?? candidates[0];
+}
+function findConfigFile(rootDir, configFile) {
+	if (configFile !== void 0) {
+		const file = resolve(process.cwd(), configFile);
+		if (!existsSync(file)) throw new LayerscopeError(`Config file not found: ${file}`);
+		return file;
+	}
+	return CONFIG_NAMES.map((name) => resolve(rootDir, name)).find((path) => existsSync(path)) ?? null;
+}
+function createLoader() {
+	const self = defineConfigModule();
+	return createJiti(import.meta.url, {
+		alias: {
+			"nuxt-layerscope": self,
+			layerscope: self
+		},
+		moduleCache: false
+	});
+}
+function toConfig(value, file) {
+	if (typeof value !== "object" || value === null) throw new LayerscopeError(`${file} must default-export a config object`);
+	validateConfig(value, file);
+	return value;
+}
+function loadFailed(file, error) {
+	return new LayerscopeError(`Failed to load ${file}: ${error.message}`);
+}
+async function loadConfig(rootDir, configFile) {
+	const file = findConfigFile(rootDir, configFile);
+	if (file === null) return {};
+	return toConfig(await createLoader().import(file, { default: true }).catch((error) => {
+		throw loadFailed(file, error);
+	}), file);
+}
+function requireConfig(file) {
+	try {
+		return createLoader()(file);
+	} catch (error) {
+		throw loadFailed(file, error);
+	}
+}
+/** For callers that cannot await, such as lint rules. */
+function loadConfigSync(rootDir) {
+	const file = findConfigFile(rootDir);
+	if (file === null) return {};
+	const module = requireConfig(file);
+	return toConfig(module?.default ?? module, file);
+}
+//#endregion
+//#region src/rules/layer-boundary.ts
+function describeEdge(edge) {
+	if (edge.kind === "component") return `Component <${edge.symbol}>`;
+	return edge.kind === "import" ? `Import "${edge.symbol}"` : `Auto-import "${edge.symbol}"`;
+}
+/** Edges to packages and within a layer are always allowed. */
+function isAllowed(edge, allow) {
+	return edge.toLayer === null || edge.toLayer === edge.fromLayer || allow.includes(edge.toLayer);
+}
+function boundaryFindings(edges, config) {
+	const severity = ruleSeverity(config, "layer-boundary");
+	if (severity === "off") return [];
+	return edges.flatMap((edge) => {
+		const allow = config.layers?.[edge.fromLayer]?.allow;
+		if (allow === void 0 || isAllowed(edge, allow)) return [];
+		return [{
+			rule: "layer-boundary",
+			severity,
+			file: edge.file,
+			line: edge.line,
+			column: edge.column,
+			symbol: edge.symbol,
+			fromLayer: edge.fromLayer,
+			toLayer: edge.toLayer,
+			target: edge.to,
+			allowed: allow,
+			message: `${describeEdge(edge)} crosses from layer "${edge.fromLayer}" into "${edge.toLayer}"`
+		}];
+	});
+}
+//#endregion
+//#region src/nuxt/symbols.ts
+const GLOBAL_CONST = /^ {2}const ([\w$]+): (.*)$/u;
+const EXPORT_CONST = /^export const ([\w$]+): (.*)$/u;
+const INTERFACE_MEMBER = /^ {2}([\w$]+): (.*)$/u;
+const TYPEOF_IMPORT = /typeof import\((['"])(.+?)\1\)/u;
+const INLINE_TYPE = {
+	file: null,
+	module: "nuxt"
+};
+/** Target of an absolute path or a bare module specifier. */
+function targetOf(source, buildDir) {
+	if (!isAbsolute(source)) return {
+		file: null,
+		module: packageName(source)
+	};
+	if (source === buildDir || source.startsWith(`${buildDir}/`)) return {
+		file: null,
+		module: "#build"
+	};
+	if (source.includes("/node_modules/")) {
+		const file = resolveFile(source);
+		return {
+			file: file === null ? null : realPath(file),
+			module: packageName(source)
+		};
+	}
+	return {
+		file: realPath(resolveFile(source) ?? source),
+		module: null
+	};
+}
+function toTarget(declaration, fromDir, buildDir) {
+	const specifier = TYPEOF_IMPORT.exec(declaration)?.[2];
+	if (specifier === void 0) return INLINE_TYPE;
+	return targetOf(specifier.startsWith(".") || specifier.startsWith("/") ? resolve(fromDir, specifier) : specifier, buildDir);
+}
+/** Only `declare global { ... }` blocks hold auto-imports; the rest are type augmentations. */
+function parseGlobalDeclarations(file, buildDir) {
+	const table = /* @__PURE__ */ new Map();
+	if (!existsSync(file)) return table;
+	let inGlobal = false;
+	for (const line of readFileSync(file, "utf8").split("\n")) {
+		if (line.startsWith("declare global") || line.startsWith("}")) {
+			inGlobal = line.startsWith("declare global");
+			continue;
+		}
+		const match = inGlobal ? GLOBAL_CONST.exec(line) : null;
+		if (match) table.set(match[1], toTarget(match[2], dirname(file), buildDir));
+	}
+	return table;
+}
+/** `.nuxt/components.d.ts`: one `export const` per component. */
+function parseComponentExports(file, buildDir) {
+	const table = /* @__PURE__ */ new Map();
+	for (const line of readFileSync(file, "utf8").split("\n")) {
+		const match = EXPORT_CONST.exec(line);
+		if (match && TYPEOF_IMPORT.test(match[2])) table.set(match[1], toTarget(match[2], dirname(file), buildDir));
+	}
+	return table;
+}
+/** `.nuxt/types/components.d.ts` (Nuxt 4.1+): members of `interface _GlobalComponents`. */
+function parseComponentInterface(file, buildDir) {
+	const table = /* @__PURE__ */ new Map();
+	let inInterface = false;
+	for (const line of readFileSync(file, "utf8").split("\n")) {
+		if (line.startsWith("interface _GlobalComponents") || line.startsWith("}")) {
+			inInterface = line.startsWith("interface _GlobalComponents");
+			continue;
+		}
+		const match = inInterface ? INTERFACE_MEMBER.exec(line) : null;
+		if (match && TYPEOF_IMPORT.test(match[2])) table.set(match[1], toTarget(match[2], dirname(file), buildDir));
+	}
+	return table;
+}
+function loadComponents(buildDir) {
+	const root = join(buildDir, "components.d.ts");
+	if (existsSync(root)) return parseComponentExports(root, buildDir);
+	const types = join(buildDir, "types/components.d.ts");
+	return existsSync(types) ? parseComponentInterface(types, buildDir) : null;
+}
+function sameTarget(a, b) {
+	return a.file === b.file && a.module === b.module;
+}
+/**
+* Nuxt 3 writes no `shared-imports.d.ts`; Nuxt 4 derives it from the imports both contexts
+* share, so the same rule applies here.
+*/
+function loadSharedImports(buildDir, app, server) {
+	const file = join(buildDir, "types/shared-imports.d.ts");
+	if (existsSync(file)) return parseGlobalDeclarations(file, buildDir);
+	return new Map([...app].filter(([name, target]) => {
+		const other = server.get(name);
+		return other !== void 0 && sameTarget(target, other);
+	}));
+}
+function loadSymbolTable(buildDir) {
+	const app = join(buildDir, "types/imports.d.ts");
+	const components = existsSync(app) ? loadComponents(buildDir) : null;
+	if (components === null) {
+		const missing = existsSync(app) ? join(buildDir, "components.d.ts") : app;
+		throw new LayerscopeError(`${missing} not found. Run "nuxi prepare" first, or pass --prepare.`);
+	}
+	const appImports = parseGlobalDeclarations(app, buildDir);
+	const serverImports = parseGlobalDeclarations(join(buildDir, "types/nitro-imports.d.ts"), buildDir);
+	return {
+		imports: {
+			app: appImports,
+			server: serverImports,
+			shared: loadSharedImports(buildDir, appImports, serverImports)
+		},
+		components
+	};
+}
+//#endregion
+//#region src/registry/read.ts
+function readRegistry(buildDir) {
+	const file = join(buildDir, REGISTRY_FILE);
+	if (!existsSync(file)) return {
+		kind: "missing",
+		file
+	};
+	const registry = readJson(file);
+	if (registry.version !== 1) return {
+		kind: "incompatible",
+		file,
+		version: registry.version
+	};
+	return {
+		kind: "ok",
+		file,
+		registry
+	};
+}
+function importMap(imports, buildDir) {
+	return new Map(imports.map((entry) => [entry.name, targetOf(entry.from, buildDir)]));
+}
+/** The same table the `.d.ts` parser builds, from Nuxt's own registry. */
+function tableFromRegistry(registry, buildDir) {
+	const components = /* @__PURE__ */ new Map();
+	const lazy = /* @__PURE__ */ new Map();
+	for (const component of registry.components) {
+		const target = targetOf(component.file, buildDir);
+		components.set(component.name, target);
+		lazy.set(`Lazy${component.name}`, target);
+	}
+	return {
+		imports: {
+			app: importMap(registry.imports.app, buildDir),
+			server: importMap(registry.imports.server, buildDir),
+			shared: importMap(registry.imports.shared, buildDir)
+		},
+		components: new Map([...components, ...lazy])
+	};
+}
+//#endregion
+//#region src/nuxt/aliases.ts
+const TSCONFIG_FILES = [
+	"tsconfig.app.json",
+	"tsconfig.json",
+	"tsconfig.server.json",
+	"tsconfig.shared.json"
+];
+/** Nuxt's alias map, as written to the generated tsconfig files. */
+function loadAliases(buildDir) {
+	const map = /* @__PURE__ */ new Map();
+	const files = TSCONFIG_FILES.map((name) => join(buildDir, name)).filter((file) => existsSync(file));
+	for (const file of files) {
+		const paths = readJson(file).compilerOptions?.paths ?? {};
+		for (const [key, targets] of Object.entries(paths)) {
+			const alias = key.replace(/\/\*$/u, "");
+			const target = targets.at(0)?.replace(/\/\*$/u, "");
+			if (target !== void 0 && !map.has(alias)) {
+				const isPath = isAbsolute(target) || target.startsWith(".");
+				map.set(alias, isPath ? resolve(buildDir, target) : target);
+			}
+		}
+	}
+	map.set("#build", buildDir);
+	return [...map].toSorted((a, b) => b[0].length - a[0].length);
+}
+//#endregion
+//#region src/analyze/known-globals.ts
+const SFC_MACROS = [
+	"defineProps",
+	"defineEmits",
+	"defineExpose",
+	"defineOptions",
+	"defineSlots",
+	"defineModel",
+	"withDefaults"
+];
+/** Defined on `globalThis` by Nuxt (app) and Nitro (server), so absent from the registry there. */
+const RUNTIME_GLOBALS = ["$fetch"];
+/** Registered globally by Vue and vue-router, so never listed in components.d.ts. */
+const GLOBAL_COMPONENTS = ["RouterLink", "RouterView"];
+function knownIdentifiers(extra) {
+	return /* @__PURE__ */ new Set([
+		...Object.keys(globals.builtin),
+		...Object.keys(globals.browser),
+		...Object.keys(globals.node),
+		...SFC_MACROS,
+		...RUNTIME_GLOBALS,
+		"undefined",
+		"arguments",
+		...extra
+	]);
+}
+function knownComponents(extra) {
+	return /* @__PURE__ */ new Set([...GLOBAL_COMPONENTS, ...extra]);
+}
+//#endregion
+//#region src/analyze/analysis-env.ts
+/** What every file analysis needs: symbols, aliases, ownership and known globals. */
+function createAnalysisEnv(table, ownerOf, buildDir, config) {
+	return {
+		table,
+		aliases: loadAliases(buildDir),
+		buildDir,
+		ownerOf,
+		identifiers: knownIdentifiers(config.globals ?? []),
+		components: knownComponents(config.globals ?? []),
+		unresolvedSeverity: ruleSeverity(config, "unresolved-reference")
+	};
+}
+//#endregion
+//#region src/nuxt/kit.ts
+function findPackageDir(from, name) {
+	for (let dir = from;; dir = dirname(dir)) {
+		const candidate = join(dir, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+		if (dirname(dir) === dir) return null;
+	}
+}
+function packageEntry(dir) {
+	const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	let entry = pkg.exports?.["."];
+	while (typeof entry === "object" && entry !== null) {
+		const conditions = entry;
+		entry = conditions.import ?? conditions.node ?? conditions.default;
+	}
+	return join(dir, typeof entry === "string" ? entry : pkg.module ?? pkg.main ?? "index.js");
+}
+/**
+* Loads `@nuxt/kit` from the project's own Nuxt install rather than bundling one, so the
+* config defaults match the project's Nuxt major version.
+*/
+async function loadNuxtKit(rootDir) {
+	let kitDir = findPackageDir(rootDir, "@nuxt/kit");
+	if (kitDir === null) {
+		const nuxtDir = findPackageDir(rootDir, "nuxt");
+		kitDir = nuxtDir === null ? null : findPackageDir(nuxtDir, "@nuxt/kit");
+	}
+	if (kitDir === null) return null;
+	return await import(pathToFileURL(packageEntry(kitDir)).href);
+}
+//#endregion
+//#region src/nuxt/validate-layers.ts
+function assertUniqueNames(layers) {
+	const roots = /* @__PURE__ */ new Map();
+	for (const layer of layers) {
+		const other = roots.get(layer.name);
+		if (other !== void 0) throw new LayerscopeError(`Two layers are named "${layer.name}" (${other} and ${layer.root}). Set "path" in layerscope.config.ts to tell them apart.`);
+		roots.set(layer.name, layer.root);
+	}
+	return new Set(roots.keys());
+}
+function validateLayers(layers, config) {
+	const names = assertUniqueNames(layers);
+	for (const [name, rule] of Object.entries(config.layers ?? {})) {
+		if (!names.has(name)) {
+			const known = [...names].toSorted().join(", ");
+			throw new LayerConfigError(`Unknown layer "${name}" in config. Known layers: ${known}`);
+		}
+		const unknown = rule.allow?.find((allowed) => !names.has(allowed));
+		if (unknown !== void 0) throw new LayerConfigError(`layers.${name}.allow: unknown layer "${unknown}"`);
+	}
+}
+//#endregion
+//#region src/nuxt/layers.ts
+function configuredPaths(rootDir, config) {
+	return Object.entries(config.layers ?? {}).flatMap(([name, rule]) => rule.path === void 0 ? [] : [[name, realPath(resolve(rootDir, rule.path))]]);
+}
+function configuredSources(config) {
+	return Object.entries(config.layers ?? {}).flatMap(([name, rule]) => rule.source === void 0 ? [] : [[name, rule.source]]);
+}
+function layersFromConfig(rootDir, config) {
+	const paths = configuredPaths(rootDir, config);
+	if (paths.length === 0) throw new LayerscopeError(`Could not load @nuxt/kit from ${rootDir}. Install dependencies, or give every layer a "path" in layerscope.config.ts.`);
+	const layers = paths.map(([name, root]) => layerFromPath(name, root));
+	const root = realPath(resolve(rootDir));
+	return layers.some((layer) => layer.root === root) ? layers : [layerFromPath(ROOT_LAYER_NAME, root), ...layers];
+}
+async function layersFromNuxt(kit, rootDir) {
+	let options = null;
+	try {
+		options = await kit.loadNuxtConfig({ cwd: rootDir });
+	} catch (error) {
+		throw new LayerscopeError(`Failed to load Nuxt config: ${error.message}`);
+	}
+	const dirs = kit.getLayerDirectories?.({ options }) ?? options._layers.map((layer, index) => deriveDirectories(layer, index, options));
+	return options._layers.map((layer, index) => layerFromNuxt(layer, index, dirs[index]));
+}
+/** `path` in config names the Nuxt layer at that root. */
+function applyConfiguredNames(layers, rootDir, config) {
+	const named = layers.map((layer) => ({ ...layer }));
+	for (const [name, root] of configuredPaths(rootDir, config)) {
+		const layer = named.find((candidate) => candidate.root === root);
+		if (layer === void 0) throw new LayerscopeError(`layers.${name}.path: no Nuxt layer at ${root}`);
+		layer.name = name;
+	}
+	for (const [name, source] of configuredSources(config)) {
+		const matches = named.filter((candidate) => isClonedFrom(candidate.root, source));
+		if (matches.length !== 1) {
+			const found = matches.length === 0 ? "no layer cloned" : "several layers cloned";
+			throw new LayerscopeError(`layers.${name}.source: ${found} from "${source}". Set $meta.name in the layer's nuxt.config instead.`);
+		}
+		matches[0].name = name;
+	}
+	return named;
+}
+/** Applies `path` names from config to recorded layers and checks config against them. */
+function nameLayers(layers, rootDir, config) {
+	const named = applyConfiguredNames(layers, rootDir, config);
+	validateLayers(named, config);
+	return named;
+}
+/**
+* The ordered layer list, highest priority first. `recorded` are the layers the Nuxt module
+* wrote to the registry; without them the layers come from the project's `@nuxt/kit`.
+*/
+async function resolveLayers(rootDir, config, recorded) {
+	let layers = recorded;
+	if (layers === void 0) {
+		const kit = await loadNuxtKit(rootDir);
+		layers = kit === null ? layersFromConfig(rootDir, config) : await layersFromNuxt(kit, rootDir);
+	}
+	return nameLayers(layers, rootDir, config);
+}
+//#endregion
+//#region src/nuxt/owner.ts
+/** The layer whose root is the longest prefix of the file; files in node_modules have none. */
+function createOwnerLookup(layers) {
+	const deepestFirst = layers.toSorted((a, b) => b.root.length - a.root.length);
+	return (file) => {
+		const layer = deepestFirst.find((candidate) => file.startsWith(`${candidate.root}/`));
+		if (layer === void 0) return null;
+		return file.slice(layer.root.length).includes("/node_modules/") ? null : layer;
+	};
+}
+//#endregion
+export { readRegistry as a, boundaryFindings as c, loadConfig as d, loadConfigSync as f, createAnalysisEnv as i, isAllowed as l, nameLayers as n, tableFromRegistry as o, resolveLayers as r, loadSymbolTable as s, createOwnerLookup as t, findConfigFile as u };

package/dist/report-DG-XzEq4.mjs

@@ -0,0 +1,2 @@
+import { n as formatResult } from "./report-jEMtNXS8.mjs";
+export { formatResult };

package/dist/{unused-BtsPSfxb.mjs → unused-DbvZ4gRV.mjs}

@@ -1,5 +1,5 @@
 import { t as compareStrings } from "./strings-CrOjNZmB.mjs";
-import { c as createOwnerLookup, g as isAllowed } from "./file-analysis-Bh7qcWUK.mjs";
+import { l as isAllowed, t as createOwnerLookup } from "./owner-BA00V9VD.mjs";
 import { relative } from "pathe";
 //#region src/rules/edge-status.ts
 /** How the layer rules see one edge. */

package/dist/{version-DFWOUgi5.mjs → version-D5JrgoO_.mjs}

@@ -1,4 +1,4 @@
-import { s as readJson } from "./layer-factory-DFh7nkFH.mjs";
+import { _ as readJson } from "./layer-factory-DVSf2Wj4.mjs";
 import { fileURLToPath } from "node:url";
 //#region src/version.ts
 /** Both `src/` and the bundled `dist/` sit next to package.json. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-layerscope",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Layer boundary checks for Nuxt apps that see auto-imports",
   "keywords": [
     "architecture",

package/dist/analyze-DVzyPH7N.mjs

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

package/dist/component-files-DgOXNE6l.mjs

@@ -1,12 +0,0 @@
-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/layer-factory-DFh7nkFH.mjs

@@ -1,182 +0,0 @@
-import { basename, dirname, join, resolve } from "pathe";
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-//#region src/errors.ts
-/** A config or input problem; the CLI exits with code 2. */
-var LayerscopeError = class extends Error {
-	constructor(..._args) {
-		super(..._args);
-		this.name = "LayerscopeError";
-	}
-};
-//#endregion
-//#region src/layer-config-error.ts
-/** A layer name in the config that matches no layer. */
-var LayerConfigError = class extends LayerscopeError {
-	constructor(..._args) {
-		super(..._args);
-		this.name = "LayerConfigError";
-	}
-};
-//#endregion
-//#region src/config/rules.ts
-const DEFAULT_SEVERITY = {
-	"layer-boundary": "error",
-	"unresolved-reference": "warn",
-	"shadowed-component": "warn"
-};
-/** Accepted in config for forward compatibility; not implemented yet. */
-const RESERVED_RULES = /* @__PURE__ */ new Set(["unused-symbol"]);
-const SEVERITIES = /* @__PURE__ */ new Set([
-	"off",
-	"warn",
-	"error"
-]);
-function isRuleName(name) {
-	return Object.hasOwn(DEFAULT_SEVERITY, name);
-}
-function ruleSeverity(config, rule) {
-	return config.rules?.[rule] ?? DEFAULT_SEVERITY[rule];
-}
-//#endregion
-//#region src/config/validate.ts
-function validateConfig(config, file) {
-	for (const [rule, severity] of Object.entries(config.rules ?? {})) {
-		if (!isRuleName(rule) && !RESERVED_RULES.has(rule)) throw new LayerscopeError(`${file}: unknown rule "${rule}"`);
-		if (!SEVERITIES.has(String(severity))) throw new LayerscopeError(`${file}: rule "${rule}" must be "off", "warn" or "error", got ${JSON.stringify(severity)}`);
-	}
-	for (const [name, layer] of Object.entries(config.layers ?? {})) {
-		if (layer.allow !== void 0 && !Array.isArray(layer.allow)) throw new LayerscopeError(`${file}: layers.${name}.allow must be an array of layer names`);
-		if (layer.path !== void 0 && layer.source !== void 0) throw new LayerscopeError(`${file}: layers.${name} sets both "path" and "source"; use one`);
-	}
-}
-//#endregion
-//#region src/config/effective.ts
-/** Where the module's options live when they come from `nuxt.config`. */
-const NUXT_CONFIG_LABEL = "nuxt.config (layerscope)";
-/** The keys that describe the project; `buildDir` only says where to look. */
-const PROJECT_CONFIG_KEYS = [
-	"layers",
-	"rules",
-	"ignore",
-	"globals"
-];
-function hasProjectConfig(config) {
-	return PROJECT_CONFIG_KEYS.some((key) => config[key] !== void 0);
-}
-function pickProjectConfig(config) {
-	return Object.fromEntries(PROJECT_CONFIG_KEYS.flatMap((key) => config[key] === void 0 ? [] : [[key, config[key]]]));
-}
-/**
-* `layerscope.config.*` or the `layerscope` key of `nuxt.config`, which the module records in the
-* registry. Both at once is an error rather than a merge, so it is always clear which one applies.
-*/
-function effectiveConfig(fileConfig, recorded) {
-	if (recorded === void 0 || !hasProjectConfig(recorded)) return fileConfig;
-	if (hasProjectConfig(fileConfig)) throw new LayerscopeError("Layers or rules are set both in layerscope.config and in the \"layerscope\" key of nuxt.config. Keep one.");
-	validateConfig(recorded, NUXT_CONFIG_LABEL);
-	return {
-		...fileConfig,
-		...recorded
-	};
-}
-/** Names the `nuxt.config` key in a layer error, when the settings that caused it came from there. */
-function labelConfigError(error, recorded) {
-	if (error instanceof LayerConfigError && recorded !== void 0 && hasProjectConfig(recorded)) return new LayerscopeError(`${NUXT_CONFIG_LABEL}: ${error.message}`);
-	return error;
-}
-//#endregion
-//#region src/registry/schema.ts
-/** Bumped on breaking changes to `registry.json`; readers fall back to the `.d.ts` files. */
-const REGISTRY_VERSION = 1;
-/** Relative to the Nuxt build dir. */
-const REGISTRY_FILE = "layerscope/registry.json";
-//#endregion
-//#region src/utils/fs.ts
-function isFile(path) {
-	try {
-		return statSync(path).isFile();
-	} catch {
-		return false;
-	}
-}
-function readJson(path) {
-	return JSON.parse(readFileSync(path, "utf8").replaceAll(/^\s*\/\/.*$/gmu, ""));
-}
-/** Symlinks resolved (pnpm links packages), or the path itself when it does not exist. */
-function realPath(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
-	}
-}
-//#endregion
-//#region src/nuxt/remote-layer.ts
-/** c12 clones remote layers into `node_modules/.c12`, or into `~/.cache/c12` without one. */
-const CLONE_DIRS = /* @__PURE__ */ new Set([".c12", "c12"]);
-/**
-* c12 names a clone after the first three word segments of its `extends` source plus a hash of
-* the whole source (`github:org/repo#v1` → `github_org_repo_<hash>`). The hash changes with the
-* ref, so names and config matching use the prefix only.
-*/
-function clonePrefix(source) {
-	return source.replaceAll(/\W+/gu, "_").split("_").slice(0, 3).join("_");
-}
-/** The clone name without its hash, so it survives ref changes; `null` for other layers. */
-function remoteLayerName(root) {
-	if (!CLONE_DIRS.has(basename(dirname(root)))) return null;
-	const name = basename(root);
-	const hashStart = name.lastIndexOf("_");
-	return hashStart === -1 ? name : name.slice(0, hashStart);
-}
-/** Whether the layer at `root` was cloned from this `extends` source. */
-function isClonedFrom(root, source) {
-	return remoteLayerName(root) === clonePrefix(source);
-}
-//#endregion
-//#region src/nuxt/layer-factory.ts
-const ROOT_LAYER_NAME = "root";
-/** Fallback for `@nuxt/kit` releases without `getLayerDirectories`. */
-function deriveDirectories(layer, index, options) {
-	const root = resolve(layer.config.rootDir ?? layer.cwd);
-	return {
-		root,
-		app: resolve(root, layer.config.srcDir ?? "."),
-		server: index === 0 && options.serverDir !== void 0 ? resolve(options.serverDir) : resolve(root, layer.config.serverDir ?? "server"),
-		shared: resolve(root, layer.config.dir?.shared ?? options.dir?.shared ?? "shared")
-	};
-}
-/** Real paths, so they match symlinked paths in generated types and imports. */
-function toDirs(dirs) {
-	const dir = (path) => realPath(resolve(path));
-	return {
-		root: dir(dirs.root),
-		srcDir: dir(dirs.app),
-		serverDir: dir(dirs.server),
-		sharedDir: dir(dirs.shared)
-	};
-}
-function layerFromNuxt(layer, index, dirs) {
-	const resolved = toDirs(dirs);
-	return {
-		name: layer.meta?.name ?? layer.config.$meta?.name ?? (index === 0 ? "root" : remoteLayerName(resolved.root) ?? basename(resolved.root)),
-		...resolved,
-		defaultComponents: layer.config.components === void 0
-	};
-}
-/** Without @nuxt/kit, assume Nuxt defaults: `app/` as srcDir when it exists (Nuxt 4). */
-function layerFromPath(name, root) {
-	const appDir = join(root, "app");
-	return {
-		name,
-		...toDirs({
-			root,
-			app: existsSync(appDir) ? appDir : root,
-			server: join(root, "server"),
-			shared: join(root, "shared")
-		}),
-		defaultComponents: true
-	};
-}
-//#endregion
-export { LayerConfigError as _, isClonedFrom as a, realPath as c, effectiveConfig as d, labelConfigError as f, ruleSeverity as g, isRuleName as h, layerFromPath as i, REGISTRY_FILE as l, validateConfig as m, deriveDirectories as n, isFile as o, pickProjectConfig as p, layerFromNuxt as r, readJson as s, ROOT_LAYER_NAME as t, REGISTRY_VERSION as u, LayerscopeError as v };

package/dist/report-CKhXT50W.mjs

@@ -1,2 +0,0 @@
-import { n as formatResult, r as isOutputFormat, t as OUTPUT_FORMATS } from "./report-DShTCB59.mjs";
-export { OUTPUT_FORMATS, formatResult, isOutputFormat };

package/dist/{report-DShTCB59.mjs → report-jEMtNXS8.mjs}

@@ -1,5 +1,5 @@
-import { t as summarize } from "./summary-DiUYKMPe.mjs";
 import { i as plural } from "./strings-CrOjNZmB.mjs";
+import { t as summarize } from "./summary-DiUYKMPe.mjs";
 import { relative } from "pathe";
 import { styleText } from "node:util";
 //#region src/utils/style.ts