nuxt-layerscope 0.1.0

package/dist/file-analysis-Bkq_69x4.mjs

@@ -0,0 +1,1085 @@
+import { a as isClonedFrom, c as realPath, g as LayerscopeError, h as ruleSeverity, i as layerFromPath, l as REGISTRY_FILE, n as deriveDirectories, o as isFile, p as validateConfig, r as layerFromNuxt, s as readJson, t as ROOT_LAYER_NAME } from "./layer-factory-xZmIAPrA.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 { 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);
+	}
+}
+/** 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];
+}
+//#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"
+];
+/** 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,
+		"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 LayerscopeError(`Unknown layer "${name}" in config. Known layers: ${known}`);
+		}
+		const unknown = rule.allow?.find((allowed) => !names.has(allowed));
+		if (unknown !== void 0) throw new LayerscopeError(`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
+//#region src/scan/ast.ts
+function stringLiteral(node) {
+	return node?.type === "Literal" && typeof node.value === "string" ? node.value : null;
+}
+function importedName(spec) {
+	if (spec.type === "ImportSpecifier") return spec.imported.type === "Identifier" ? spec.imported.name : String(spec.imported.value);
+	return spec.type === "ImportDefaultSpecifier" ? "default" : "*";
+}
+function reexportedName(spec) {
+	if (spec.type !== "ExportSpecifier") return "*";
+	return spec.local.type === "Identifier" ? spec.local.name : String(spec.local.value);
+}
+//#endregion
+//#region src/scan/script-visitors.ts
+function skip() {
+	this.skip();
+}
+const scriptVisitors = {
+	ImportDeclaration(node, _parent, { scan, mapOffset }) {
+		if (node.type !== "ImportDeclaration") return;
+		scan.imports.push({
+			specifier: node.source.value,
+			names: node.specifiers.length > 0 ? node.specifiers.map(importedName) : ["*"],
+			offset: mapOffset(node.source.start)
+		});
+		this.skip();
+	},
+	ExportNamedDeclaration(node, _parent, { scan, mapOffset }) {
+		if (node.type !== "ExportNamedDeclaration" || !node.source) return;
+		scan.imports.push({
+			specifier: node.source.value,
+			names: node.specifiers.map(reexportedName),
+			offset: mapOffset(node.source.start)
+		});
+		this.skip();
+	},
+	ExportAllDeclaration(node, _parent, { scan, mapOffset }) {
+		if (node.type !== "ExportAllDeclaration") return;
+		scan.imports.push({
+			specifier: node.source.value,
+			names: ["*"],
+			offset: mapOffset(node.source.start)
+		});
+		this.skip();
+	},
+	ImportExpression(node, _parent, { scan, mapOffset }) {
+		if (node.type !== "ImportExpression") return;
+		const specifier = stringLiteral(node.source);
+		if (specifier !== null) scan.imports.push({
+			specifier,
+			names: ["*"],
+			offset: mapOffset(node.source.start)
+		});
+	},
+	TSModuleDeclaration: skip,
+	TSImportType: skip,
+	CallExpression(node, _parent, { scan, mapOffset }) {
+		if (node.type !== "CallExpression" || node.callee.type !== "Identifier") return;
+		const [arg] = node.arguments;
+		if (node.callee.name !== "resolveComponent" || arg === void 0) return;
+		const name = stringLiteral(arg);
+		if (name === null) scan.dynamicComponents.push(mapOffset(arg.start));
+		else scan.components.push({
+			name,
+			offset: mapOffset(arg.start)
+		});
+	},
+	Identifier(node, parent, { scan, tracker, mapOffset }) {
+		if (node.type === "Identifier" && isReferenceIdentifier(node, parent) && !tracker.isDeclared(node.name)) scan.free.push({
+			name: node.name,
+			offset: mapOffset(node.start)
+		});
+	}
+};
+//#endregion
+//#region src/scan/types.ts
+function emptyScan() {
+	return {
+		free: [],
+		templateIdents: [],
+		components: [],
+		dynamicComponents: [],
+		imports: [],
+		error: null
+	};
+}
+function toLang(lang) {
+	return lang === "ts" || lang === "tsx" || lang === "jsx" ? lang : "js";
+}
+//#endregion
+//#region src/scan/script.ts
+/**
+* Parses and pre-walks the code so hoisted declarations are known before references are
+* checked; a local `useFoo` then correctly shadows the auto-imported one.
+*/
+function parseScoped(code, lang) {
+	const tracker = new ScopeTracker({ preserveExitedScopes: true });
+	const parsed = parseAndWalk(code, `file.${lang}`, {
+		scopeTracker: tracker,
+		parseOptions: {
+			lang,
+			sourceType: "module"
+		}
+	});
+	tracker.freeze();
+	const first = parsed.errors.at(0);
+	const error = first === void 0 ? null : {
+		message: first.message,
+		start: first.labels[0]?.start ?? 0
+	};
+	return {
+		program: parsed.program,
+		tracker,
+		error
+	};
+}
+function scanScript(code, lang, mapOffset, scan) {
+	const { program, tracker, error } = parseScoped(code, lang);
+	if (error !== null) {
+		scan.error = {
+			message: error.message,
+			offset: mapOffset(error.start)
+		};
+		return;
+	}
+	const ctx = {
+		scan,
+		tracker,
+		mapOffset
+	};
+	walk(program, {
+		scopeTracker: tracker,
+		enter(node, parent) {
+			scriptVisitors[node.type]?.call(this, node, parent, ctx);
+		}
+	});
+}
+function collectTopLevelNames(code, lang) {
+	const { program, tracker } = parseScoped(code, lang);
+	const bindings = {};
+	walk(program, {
+		scopeTracker: tracker,
+		enter(node) {
+			if (node.type === "Identifier" && tracker.getDeclaration(node.name)?.scope === "") bindings[node.name] = "setup-maybe-ref";
+		}
+	});
+	return bindings;
+}
+function scanModule(code, file) {
+	const scan = emptyScan();
+	const ext = /\.[cm]?([jt]sx?)$/u.exec(file)?.[1];
+	scanScript(code, toLang(ext), (offset) => offset, scan);
+	return scan;
+}
+//#endregion
+//#region src/scan/render-visitors.ts
+/** `$setup.X` where X is a const binding, such as an imported component. */
+function isSetupConst(arg, bindings) {
+	if (arg?.type !== "MemberExpression" || arg.object.type !== "Identifier") return false;
+	if (arg.object.name !== "$setup") return false;
+	const key = arg.property.type === "Identifier" && !arg.computed ? arg.property.name : stringLiteral(arg.property);
+	return key !== null && bindings[key] === "setup-const";
+}
+function visitDynamicComponent(arg, ctx) {
+	const literal = stringLiteral(arg);
+	if (literal !== null) ctx.scan.components.push({
+		name: pascalCase(literal),
+		offset: ctx.elementOffset((el) => el.isAttr === literal)
+	});
+	else if (!isSetupConst(arg, ctx.bindings)) ctx.scan.dynamicComponents.push(ctx.elementOffset((el) => el.dynamicIs));
+}
+function visitRenderCall(node, ctx) {
+	if (node.type !== "CallExpression" || node.callee.type !== "Identifier") return;
+	const arg = node.arguments[0];
+	const literal = stringLiteral(arg);
+	if (node.callee.name === "_resolveComponent" && literal !== null) {
+		const name = pascalCase(literal);
+		ctx.scan.components.push({
+			name,
+			offset: ctx.elementOffset((el) => pascalCase(el.tag) === name)
+		});
+	} else if (node.callee.name === "_resolveDynamicComponent") visitDynamicComponent(arg, ctx);
+}
+function visitRenderMember(node, ctx) {
+	if (node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "_ctx" && node.property.type === "Identifier") {
+		const { name } = node.property;
+		ctx.scan.templateIdents.push({
+			name,
+			offset: ctx.identOffset(name)
+		});
+	}
+}
+//#endregion
+//#region src/scan/template-index.ts
+const ELEMENT = 1;
+const INTERPOLATION = 5;
+const ATTRIBUTE = 6;
+const DIRECTIVE = 7;
+function indexElement(node, index) {
+	let isAttr = null;
+	let dynamicIs = false;
+	for (const prop of node.props ?? []) {
+		if (prop.type === ATTRIBUTE && prop.name === "is") isAttr = prop.value?.content ?? null;
+		if (prop.type === DIRECTIVE) {
+			dynamicIs ||= prop.name === "bind" && prop.arg?.content === "is";
+			for (const part of [prop.exp, prop.arg]) if (part !== void 0) index.expressions.push([part.loc.start.offset, part.loc.end.offset]);
+		}
+	}
+	index.elements.push({
+		tag: node.tag ?? "",
+		offset: node.loc.start.offset,
+		isAttr,
+		dynamicIs
+	});
+}
+/** Element and expression positions, to point findings back at the source template. */
+function indexTemplate(root) {
+	const index = {
+		elements: [],
+		expressions: []
+	};
+	const visit = (node) => {
+		if (node.type === ELEMENT) indexElement(node, index);
+		if (node.type === INTERPOLATION && typeof node.content === "object") index.expressions.push([node.content.loc.start.offset, node.content.loc.end.offset]);
+		for (const child of node.children ?? []) visit(child);
+	};
+	visit(root);
+	return index;
+}
+//#endregion
+//#region src/scan/template.ts
+function firstIdentOffset(name, source, index) {
+	const pattern = new RegExp(`(?<![\\w$.])${escapeRegExp(name)}(?![\\w$])`, "u");
+	for (const [start, end] of index.expressions) {
+		const match = pattern.exec(source.slice(start, end));
+		if (match) return start + match.index;
+	}
+	return null;
+}
+/**
+* Compiles the template like Vue does and reads what the render function resolves at runtime:
+* `_resolveComponent("X")` for components and `_ctx.x` for identifiers without a setup binding.
+* The compiler already handles v-for and slot scopes, so no template scope analysis is needed.
+*/
+function scanTemplate(descriptor, source, bindings, scan) {
+	const { template } = descriptor;
+	if (!template?.ast || template.lang !== void 0 && template.lang !== "html") return;
+	const templateStart = template.loc.start.offset;
+	const compiled = compileTemplate({
+		source: template.content,
+		filename: descriptor.filename,
+		id: "layerscope",
+		compilerOptions: {
+			bindingMetadata: bindings,
+			prefixIdentifiers: true
+		}
+	});
+	const error = compiled.errors.at(0);
+	if (error !== void 0) {
+		scan.error = {
+			message: typeof error === "string" ? error : error.message,
+			offset: templateStart
+		};
+		return;
+	}
+	const index = indexTemplate(template.ast);
+	const ctx = {
+		scan,
+		bindings,
+		elementOffset: (predicate) => index.elements.find(predicate)?.offset ?? templateStart,
+		identOffset: (name) => firstIdentOffset(name, source, index) ?? templateStart
+	};
+	const { program } = parseAndWalk(compiled.code, "render.js", { parseOptions: { lang: "js" } });
+	walk(program, { enter(node) {
+		visitRenderCall(node, ctx);
+		visitRenderMember(node, ctx);
+	} });
+}
+//#endregion
+//#region src/scan/vue.ts
+/** `<script>` and `<script setup>` share one module scope, so they are scanned as one program. */
+function combineScripts(blocks, descriptor) {
+	const starts = [];
+	let at = 0;
+	for (const block of blocks) {
+		starts.push([at, block.loc.start.offset]);
+		at += block.content.length + 1;
+	}
+	return {
+		code: blocks.map((block) => block.content).join("\n"),
+		lang: toLang(descriptor.scriptSetup?.lang ?? descriptor.script?.lang),
+		mapOffset: (offset) => {
+			const [combined, original] = starts.findLast(([start]) => start <= offset) ?? [0, 0];
+			return original + offset - combined;
+		}
+	};
+}
+function templateBindings(descriptor, script) {
+	try {
+		return compileScript(descriptor, { id: "layerscope" }).bindings ?? {};
+	} catch {
+		return collectTopLevelNames(script.code, script.lang);
+	}
+}
+function scanVue(source, file) {
+	const scan = emptyScan();
+	const { descriptor, errors } = parse(source, {
+		filename: file,
+		ignoreEmpty: true
+	});
+	const error = errors.at(0);
+	if (error !== void 0) {
+		scan.error = {
+			message: error.message,
+			offset: 0
+		};
+		return scan;
+	}
+	const blocks = [descriptor.script, descriptor.scriptSetup].filter((block) => block !== null);
+	let bindings = {};
+	if (blocks.length > 0) {
+		const script = combineScripts(blocks, descriptor);
+		scanScript(script.code, script.lang, script.mapOffset, scan);
+		if (scan.error !== null) return scan;
+		bindings = templateBindings(descriptor, script);
+	}
+	scanTemplate(descriptor, source, bindings, scan);
+	return scan;
+}
+//#endregion
+//#region src/scan/index.ts
+function scanFile(source, file) {
+	return file.endsWith(".vue") ? scanVue(source, file) : scanModule(source, file);
+}
+//#endregion
+//#region src/utils/position.ts
+/** 1-based line and column of a character offset. */
+function lineColumn(source, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let i = source.indexOf("\n"); i !== -1 && i < offset; i = source.indexOf("\n", i + 1)) {
+		line += 1;
+		lineStart = i + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+/** Character offset of a 1-based line and column; the inverse of `lineColumn`. */
+function offsetAt(source, { line, column }) {
+	let lineStart = 0;
+	for (let current = 1; current < line; current += 1) lineStart = source.indexOf("\n", lineStart) + 1;
+	return lineStart + column - 1;
+}
+//#endregion
+//#region src/analyze/files.ts
+const SOURCE_GLOB = "**/*.{vue,ts,tsx,mts,js,jsx,mjs}";
+const DEFAULT_IGNORE = [
+	"**/node_modules/**",
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/dist/**",
+	"**/*.d.ts",
+	"**/*.d.mts",
+	"**/nuxt.config.*",
+	"**/.config/**",
+	"**/*.{test,spec}.*",
+	"**/__tests__/**",
+	"modules/**",
+	"public/**",
+	"layerscope.config.*"
+];
+function scannedDirs(layer) {
+	if (layer.root.includes("/node_modules/")) return [];
+	return [.../* @__PURE__ */ new Set([
+		layer.srcDir,
+		layer.serverDir,
+		layer.sharedDir
+	])].filter((dir) => existsSync(dir));
+}
+/** Whether `collectFiles` would pick up this file of the given layer. */
+function isCheckedFile(file, layer, ignore) {
+	const dir = scannedDirs(layer).find((candidate) => file.startsWith(`${candidate}/`));
+	if (dir === void 0) return false;
+	const relativePath = relative(dir, file);
+	return path.matchesGlob(relativePath, SOURCE_GLOB) && ![...DEFAULT_IGNORE, ...ignore].some((pattern) => path.matchesGlob(relativePath, pattern));
+}
+/** Source files of every layer, sorted, mapped to the layer that owns them. */
+async function collectFiles(layers, ownerOf, ignore) {
+	const jobs = layers.flatMap((layer) => scannedDirs(layer).map(async (dir) => {
+		return (await glob(SOURCE_GLOB, {
+			cwd: dir,
+			absolute: true,
+			ignore: [...DEFAULT_IGNORE, ...ignore]
+		})).filter((file) => ownerOf(file) === layer).map((file) => [file, layer]);
+	}));
+	const entries = (await Promise.all(jobs)).flat();
+	return new Map(entries.toSorted(([a], [b]) => compareStrings(a, b)));
+}
+function contextOf(file, layer) {
+	if (file.startsWith(`${layer.serverDir}/`)) return "server";
+	if (file.startsWith(`${layer.sharedDir}/`)) return "shared";
+	return "app";
+}
+//#endregion
+//#region src/resolve/specifier.ts
+function isRelative(specifier) {
+	return /^\.\.?(?:\/|$)/u.test(specifier);
+}
+function resolvePath(path, buildDir) {
+	if (path === buildDir || path.startsWith(`${buildDir}/`)) return {
+		kind: "external",
+		module: "#build"
+	};
+	const file = resolveFile(path);
+	if (file === null) return { kind: "missing" };
+	const module = file.includes("/node_modules/") ? packageName(file) : null;
+	return {
+		kind: "file",
+		file: realPath(file),
+		module
+	};
+}
+function resolveAlias(specifier, aliases, buildDir) {
+	const match = aliases.find(([alias]) => specifier === alias || specifier.startsWith(`${alias}/`));
+	if (match === void 0) return null;
+	const [alias, target] = match;
+	const path = target + specifier.slice(alias.length);
+	return isAbsolute(target) ? resolvePath(path, buildDir) : {
+		kind: "external",
+		module: packageName(path)
+	};
+}
+function resolveSpecifier(specifier, fromFile, aliases, buildDir) {
+	if (isRelative(specifier)) return resolvePath(resolve(dirname(fromFile), specifier), buildDir);
+	if (isAbsolute(specifier)) return resolvePath(specifier, buildDir);
+	const aliased = resolveAlias(specifier, aliases, buildDir);
+	if (aliased !== null) return aliased;
+	if (specifier.startsWith("#") || specifier.includes(":")) return {
+		kind: "external",
+		module: specifier.split("/")[0]
+	};
+	return {
+		kind: "external",
+		module: packageName(specifier)
+	};
+}
+//#endregion
+//#region src/analyze/import-refs.ts
+function virtualModule(specifier, context, table) {
+	if (specifier === "#imports") return table.imports[context];
+	return specifier === "#components" ? table.components : null;
+}
+/** `#imports` and `#components` are resolved by name through the symbol table. */
+function resolveImportRef(ref, file, context, env) {
+	const virtual = virtualModule(ref.specifier, context, env.table);
+	if (virtual !== null) return ref.names.map((name) => {
+		const target = virtual.get(name);
+		return target === void 0 ? {
+			resolved: false,
+			message: `"${name}" is not exported by ${ref.specifier}`
+		} : {
+			resolved: true,
+			symbol: `${ref.specifier}:${name}`,
+			target: {
+				to: target.file,
+				external: target.module
+			}
+		};
+	});
+	const resolution = resolveSpecifier(ref.specifier, file, env.aliases, env.buildDir);
+	if (resolution.kind === "missing") return [{
+		resolved: false,
+		message: `Cannot resolve import "${ref.specifier}"`
+	}];
+	const target = resolution.kind === "file" ? {
+		to: resolution.file,
+		external: resolution.module
+	} : {
+		to: null,
+		external: resolution.module
+	};
+	return [{
+		resolved: true,
+		symbol: ref.specifier,
+		target
+	}];
+}
+//#endregion
+//#region src/analyze/file-analysis.ts
+/** Runtime registrations (plugins, `app.component`, `vueApp.use`) are invisible statically. */
+const GLOBALS_HINT = "if it is registered at runtime, add it to \"globals\" in layerscope.config.ts";
+/** Turns one file's scan into dependency edges and unresolved-reference findings. */
+var FileAnalysis = class {
+	constructor(file, source, layer, env) {
+		this.edges = [];
+		this.unresolved = [];
+		this.hasDynamicComponent = false;
+		this.seen = /* @__PURE__ */ new Set();
+		this.file = file;
+		this.source = source;
+		this.layer = layer;
+		this.env = env;
+		this.context = contextOf(file, layer);
+	}
+	run(scan) {
+		if (scan.error !== null) {
+			this.addUnresolved("<parse error>", scan.error.offset, `Could not parse file: ${scan.error.message}`);
+			return this;
+		}
+		this.addIdentifiers(scan);
+		this.addComponents(scan);
+		this.addImports(scan);
+		return this;
+	}
+	addIdentifiers(scan) {
+		const imports = this.env.table.imports[this.context];
+		for (const ref of scan.free) {
+			const target = imports.get(ref.name);
+			if (target !== void 0) this.addEdge("auto-import", ref.name, ref.offset, {
+				to: target.file,
+				external: target.module
+			});
+			else if (!this.env.identifiers.has(ref.name)) this.addUnresolved(ref.name, ref.offset, `"${ref.name}" is not a local binding, a known global or an auto-import in the ${this.context} context; ${GLOBALS_HINT}`);
+		}
+		for (const ref of scan.templateIdents) {
+			const target = imports.get(ref.name);
+			if (target !== void 0) this.addEdge("auto-import", ref.name, ref.offset, {
+				to: target.file,
+				external: target.module
+			});
+		}
+	}
+	addComponents(scan) {
+		for (const ref of scan.components) {
+			const target = this.env.table.components.get(ref.name);
+			if (target !== void 0) this.addEdge("component", ref.name, ref.offset, {
+				to: target.file,
+				external: target.module
+			});
+			else if (!this.env.components.has(ref.name)) this.addUnresolved(ref.name, ref.offset, `Component <${ref.name}> is not in components.d.ts; ${GLOBALS_HINT}`);
+		}
+		this.hasDynamicComponent = scan.dynamicComponents.length > 0;
+		for (const offset of scan.dynamicComponents) this.addUnresolved("<component :is>", offset, "Dynamic component bound to a runtime value cannot be resolved statically");
+	}
+	addImports(scan) {
+		for (const ref of scan.imports) for (const outcome of resolveImportRef(ref, this.file, this.context, this.env)) if (outcome.resolved) this.addEdge("import", outcome.symbol, ref.offset, outcome.target);
+		else this.addUnresolved(ref.specifier, ref.offset, outcome.message);
+	}
+	reference(kind, symbol, offset) {
+		return {
+			file: this.file,
+			...lineColumn(this.source, offset),
+			kind,
+			symbol
+		};
+	}
+	/** Only the first use of a symbol per file is recorded. */
+	firstSeen(key) {
+		if (this.seen.has(key)) return false;
+		this.seen.add(key);
+		return true;
+	}
+	addEdge(kind, symbol, offset, target) {
+		if (!this.firstSeen(`${kind}\0${symbol}`)) return;
+		const toLayer = target.to === null ? null : this.env.ownerOf(target.to);
+		const isPackage = toLayer === null && target.external !== null;
+		this.edges.push({
+			...this.reference(kind, symbol, offset),
+			fromLayer: this.layer.name,
+			to: isPackage ? null : target.to,
+			toLayer: toLayer?.name ?? null,
+			external: toLayer === null ? target.external ?? "unknown" : null
+		});
+	}
+	addUnresolved(symbol, offset, message) {
+		const severity = this.env.unresolvedSeverity;
+		if (severity === "off" || !this.firstSeen(`unresolved\0${symbol}`)) return;
+		this.unresolved.push({
+			rule: "unresolved-reference",
+			severity,
+			file: this.file,
+			...lineColumn(this.source, offset),
+			symbol,
+			fromLayer: this.layer.name,
+			toLayer: null,
+			target: null,
+			message
+		});
+	}
+};
+/** Reads, scans and analyzes one source file. */
+function analyzeFile(file, layer, env) {
+	const source = readFileSync(file, "utf8");
+	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 };