nuxt-layerscope 0.1.3 → 0.1.4

package/dist/{file-analysis-Bh7qcWUK.mjs → layer-factory-DVSf2Wj4.mjs}

@@ -1,490 +1,113 @@
-import { _ as LayerConfigError, a as isClonedFrom, c as realPath, g as ruleSeverity, i as layerFromPath, l as REGISTRY_FILE, m as validateConfig, n as deriveDirectories, o as isFile, r as layerFromNuxt, s as readJson, t as ROOT_LAYER_NAME, v as LayerscopeError } from "./layer-factory-DFh7nkFH.mjs";
 import { n as escapeRegExp, r as pascalCase, t as compareStrings } from "./strings-CrOjNZmB.mjs";
-import { dirname, isAbsolute, join, relative, resolve } from "pathe";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { glob } from "tinyglobby";
-import { createJiti } from "jiti";
-import globals from "globals";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "pathe";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { ScopeTracker, isReferenceIdentifier, parseAndWalk, walk } from "oxc-walker";
 import { compileScript, compileTemplate, parse } from "@vue/compiler-sfc";
 import path from "node:path";
-//#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);
+import { glob } from "tinyglobby";
+//#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";
 	}
-}
-/** 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/resolve/file.ts
-const EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts",
-	".js",
-	".mjs",
-	".jsx",
-	".vue",
-	".json"
-];
-function withTsExtension(path) {
-	const jsExt = /\.(m?)js$/u.exec(path);
-	if (!jsExt) return null;
-	const base = path.slice(0, -jsExt[0].length);
-	return [`${base}.${jsExt[1]}ts`, `${base}.tsx`].find((candidate) => isFile(candidate)) ?? null;
-}
-/** Bundler-style lookup: exact, added extension, `.js` → `.ts`, then `index.*`. */
-function resolveFile(path) {
-	const direct = [path, ...EXTENSIONS.map((ext) => path + ext)].find((candidate) => isFile(candidate));
-	if (direct !== void 0) return direct;
-	return withTsExtension(path) ?? EXTENSIONS.map((ext) => join(path, `index${ext}`)).find((candidate) => isFile(candidate)) ?? null;
-}
+};
 //#endregion
-//#region src/resolve/package-name.ts
-const NODE_MODULES = "/node_modules/";
-/** Package name of a bare specifier or of a path inside node_modules. */
-function packageName(specifier) {
-	const index = specifier.lastIndexOf(NODE_MODULES);
-	const bare = index === -1 ? specifier : specifier.slice(index + 14);
-	const parts = bare.split("/");
-	return bare.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-}
+//#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/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"
+//#region src/config/rules.ts
+const DEFAULT_SEVERITY = {
+	"layer-boundary": "error",
+	"unresolved-reference": "warn",
+	"shadowed-component": "warn"
 };
-/** 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
-	};
+/** 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/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);
+//#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)}`);
 	}
-	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);
-			}
-		}
+	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`);
 	}
-	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"
+//#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"
 ];
-/** 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 hasProjectConfig(config) {
+	return PROJECT_CONFIG_KEYS.some((key) => config[key] !== void 0);
 }
-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");
+function pickProjectConfig(config) {
+	return Object.fromEntries(PROJECT_CONFIG_KEYS.flatMap((key) => config[key] === void 0 ? [] : [[key, config[key]]]));
 }
 /**
-* 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.
+* `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.
 */
-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 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
+	};
 }
-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}"`);
-	}
+/** 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/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;
+//#region src/utils/fs.ts
+function isFile(path) {
 	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 statSync(path).isFile();
+	} catch {
+		return false;
 	}
-	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;
+function readJson(path) {
+	return JSON.parse(readFileSync(path, "utf8").replaceAll(/^\s*\/\/.*$/gmu, ""));
 }
-/**
-* 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);
+/** Symlinks resolved (pnpm links packages), or the path itself when it does not exist. */
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
 	}
-	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
 //#region src/scan/ast.ts
@@ -900,6 +523,40 @@ function contextOf(file, layer) {
 	return "app";
 }
 //#endregion
+//#region src/resolve/file.ts
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".js",
+	".mjs",
+	".jsx",
+	".vue",
+	".json"
+];
+function withTsExtension(path) {
+	const jsExt = /\.(m?)js$/u.exec(path);
+	if (!jsExt) return null;
+	const base = path.slice(0, -jsExt[0].length);
+	return [`${base}.${jsExt[1]}ts`, `${base}.tsx`].find((candidate) => isFile(candidate)) ?? null;
+}
+/** Bundler-style lookup: exact, added extension, `.js` → `.ts`, then `index.*`. */
+function resolveFile(path) {
+	const direct = [path, ...EXTENSIONS.map((ext) => path + ext)].find((candidate) => isFile(candidate));
+	if (direct !== void 0) return direct;
+	return withTsExtension(path) ?? EXTENSIONS.map((ext) => join(path, `index${ext}`)).find((candidate) => isFile(candidate)) ?? null;
+}
+//#endregion
+//#region src/resolve/package-name.ts
+const NODE_MODULES = "/node_modules/";
+/** Package name of a bare specifier or of a path inside node_modules. */
+function packageName(specifier) {
+	const index = specifier.lastIndexOf(NODE_MODULES);
+	const bare = index === -1 ? specifier : specifier.slice(index + 14);
+	const parts = bare.split("/");
+	return bare.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+//#endregion
 //#region src/resolve/specifier.ts
 function isRelative(specifier) {
 	return /^\.\.?(?:\/|$)/u.test(specifier);
@@ -923,10 +580,18 @@ function resolveAlias(specifier, aliases, buildDir) {
 	if (match === void 0) return null;
 	const [alias, target] = match;
 	const path = target + specifier.slice(alias.length);
-	return isAbsolute(target) ? resolvePath(path, buildDir) : {
+	if (!isAbsolute(target)) return {
 		kind: "external",
 		module: packageName(path)
 	};
+	const resolution = resolvePath(path, buildDir);
+	const manifest = join(target, "package.json");
+	if (resolution.kind !== "missing" || !isFile(manifest)) return resolution;
+	const { name } = readJson(manifest);
+	return {
+		kind: "external",
+		module: name ?? packageName(target)
+	};
 }
 function resolveSpecifier(specifier, fromFile, aliases, buildDir) {
 	if (isRelative(specifier)) return resolvePath(resolve(dirname(fromFile), specifier), buildDir);
@@ -1092,4 +757,78 @@ function analyzeFile(file, layer, env) {
 	return new FileAnalysis(file, source, layer, env).run(scanFile(source, file));
 }
 //#endregion
-export { findConfigFile as _, lineColumn as a, createOwnerLookup as c, createAnalysisEnv as d, readRegistry as f, isAllowed as g, boundaryFindings as h, isCheckedFile as i, nameLayers as l, loadSymbolTable as m, analyzeFile as n, offsetAt as o, tableFromRegistry as p, collectFiles as r, scanFile as s, FileAnalysis as t, resolveLayers as u, loadConfig as v, loadConfigSync as y };
+//#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/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 { isRuleName as C, LayerscopeError as E, validateConfig as S, LayerConfigError as T, readJson as _, isClonedFrom as a, labelConfigError as b, FileAnalysis as c, resolveFile as d, collectFiles as f, scanFile as g, offsetAt as h, layerFromPath as i, analyzeFile as l, lineColumn as m, deriveDirectories as n, REGISTRY_FILE as o, isCheckedFile as p, layerFromNuxt as r, REGISTRY_VERSION as s, ROOT_LAYER_NAME as t, packageName as u, realPath as v, ruleSeverity as w, pickProjectConfig as x, effectiveConfig as y };