nuxt-layerscope 0.1.2 → 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/{report-BNW0GCl9.mjs → report-jEMtNXS8.mjs}

@@ -1,6 +1,15 @@
-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
+/** No styles: what the report functions use unless the CLI passes a painter for its terminal. */
+const plain = (_format, text) => text;
+/** Styles only when `stream` is a terminal; `NO_COLOR` and `FORCE_COLOR` are honoured. */
+function paintFor(stream) {
+	return (format, text) => styleText(format, text, { stream });
+}
+//#endregion
 //#region src/report/baseline.ts
 /** `layer-boundary useCart → web (×2)` */
 function describeEntry(entry) {
@@ -87,8 +96,8 @@ function formatJson(result, cwd) {
 //#endregion
 //#region src/report/text.ts
 const DETAIL_INDENT = " ".repeat(17);
-function formatFinding(finding, cwd) {
-	return [`  ${`${finding.line}:${finding.column}`.padEnd(8)}${finding.severity.padEnd(7)}${finding.message}  ${finding.rule}`, ...findingDetails(finding, cwd).map((detail) => `${DETAIL_INDENT}${detail}`)].join("\n");
+function formatFinding(finding, cwd, paint) {
+	return [`  ${paint("dim", `${finding.line}:${finding.column}`.padEnd(8))}${paint(finding.severity === "error" ? "red" : "yellow", finding.severity) + " ".repeat(7 - finding.severity.length)}${finding.message}  ${paint("dim", finding.rule)}`, ...findingDetails(finding, cwd).map((detail) => `${DETAIL_INDENT}${paint("dim", detail)}`)].join("\n");
 }
 function formatRemovable(baseline, cwd) {
 	if (baseline.removable.length === 0) return null;
@@ -96,17 +105,22 @@ function formatRemovable(baseline, cwd) {
 	const count = baseline.removable.length;
 	return [`${relative(cwd, baseline.file)}: ${plural(count, "fixed entry", "fixed entries")}. ${UPDATE_HINT} ${count === 1 ? "it" : "them"}.`, ...entries].join("\n");
 }
-function formatFooter(result) {
+function formatFooter(result, paint) {
 	const suppressed = result.baseline?.suppressed.length ?? 0;
 	const baselined = suppressed > 0 ? `, ${suppressed} more in the baseline` : "";
-	if (result.findings.length === 0) return `✔ No problems in ${plural(result.files.length, "file")} across ${plural(result.layers.length, "layer")}${baselined}`;
+	if (result.findings.length === 0) return `${paint(["green", "bold"], `✔ No problems in ${plural(result.files.length, "file")} across ${plural(result.layers.length, "layer")}`)}${baselined}`;
 	const { errors, warnings } = summarize(result.findings);
-	return `✖ ${plural(result.findings.length, "problem")} (${plural(errors, "error")}, ${plural(warnings, "warning")})${baselined}`;
+	const counts = `✖ ${plural(result.findings.length, "problem")} (${plural(errors, "error")}, ${plural(warnings, "warning")})`;
+	return `${paint(["bold", errors > 0 ? "red" : "yellow"], counts)}${baselined}`;
+}
+function hasError(findings) {
+	return findings.some((finding) => finding.severity === "error");
 }
-function formatText(result, cwd) {
-	const sections = [...Map.groupBy(result.findings, (finding) => relative(cwd, finding.file))].map(([file, findings]) => [file, ...findings.map((finding) => formatFinding(finding, cwd))].join("\n"));
+/** Files with errors come last, next to the summary, where they are least likely to scroll away. */
+function formatText(result, cwd, paint = plain) {
+	const sections = [...Map.groupBy(result.findings, (finding) => relative(cwd, finding.file))].toSorted(([, a], [, b]) => Number(hasError(a)) - Number(hasError(b))).map(([file, findings]) => [paint("underline", file), ...findings.map((finding) => formatFinding(finding, cwd, paint))].join("\n"));
 	const removable = result.baseline === void 0 ? null : formatRemovable(result.baseline, cwd);
-	return `${[...removable === null ? sections : [...sections, removable], formatFooter(result)].join("\n\n")}\n`;
+	return `${[...removable === null ? sections : [...sections, removable], formatFooter(result, paint)].join("\n\n")}\n`;
 }
 //#endregion
 //#region src/report/index.ts
@@ -123,9 +137,9 @@ const formatters = {
 function isOutputFormat(value) {
 	return Object.hasOwn(formatters, value);
 }
-/** Paths in the output are relative to `cwd`. */
-function formatResult(result, format, cwd = process.cwd()) {
-	return formatters[format](result, cwd);
+/** Paths in the output are relative to `cwd`. Only the text format uses `paint`. */
+function formatResult(result, format, cwd = process.cwd(), paint = plain) {
+	return formatters[format](result, cwd, paint);
 }
 //#endregion
-export { JSON_REPORT_VERSION as i, formatResult as n, isOutputFormat as r, OUTPUT_FORMATS as t };
+export { paintFor as a, JSON_REPORT_VERSION as i, formatResult as n, isOutputFormat as r, OUTPUT_FORMATS as t };

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.2",
+  "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 };