@vizejs/nuxt 0.312.0 → 0.318.0

package/dist/generation-bpnsF4y-.mjs

@@ -0,0 +1,1201 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { glob, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { Worker, isMainThread, parentPort } from "node:worker_threads";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { randomBytes, randomUUID } from "node:crypto";
+import { buildNuxtLintPlan, collectNuxtLintDirs, resolveNuxtLintFeatures } from "@vizejs/nuxt-lint-config";
+import { createServer } from "node:http";
+//#region src/lint/checker/options.ts
+/**
+* Resolve the engine-neutral part of `@nuxt/eslint`'s checker contract.
+*
+* `configType` and `eslintPath` intentionally do not exist: they choose an
+* ESLint implementation, while this checker always executes oxlint + Patina.
+*/
+function resolveNuxtLintCheckerOptions(checker, project) {
+	if (checker !== true && (checker === false || checker == null)) return false;
+	const overrides = typeof checker === "object" ? checker : {};
+	return {
+		cache: overrides.cache ?? true,
+		include: [...overrides.include ?? [`${project.srcDir}/**/*.{js,jsx,ts,tsx,vue}`]],
+		exclude: [...overrides.exclude ?? ["**/node_modules/**", project.buildDir]],
+		formatter: overrides.formatter ?? "stylish",
+		lintOnStart: overrides.lintOnStart ?? true,
+		emitWarning: overrides.emitWarning ?? true,
+		emitError: overrides.emitError ?? true,
+		fix: overrides.fix ?? false
+	};
+}
+//#endregion
+//#region src/lint/checker/filter.ts
+const GLOB_TOKEN = /[*?[\]{}()]/u;
+function normalize(value) {
+	const normalized = value.replaceAll("\\", "/").replace(/\/{2,}/gu, "/");
+	if (normalized === "/" || /^[A-Za-z]:\/$/u.test(normalized)) return normalized;
+	return normalized.replace(/\/$/u, "");
+}
+function relativeToRoot(file, rootDir) {
+	const root = normalize(rootDir);
+	const absolute = normalize(file);
+	const prefix = `${root}/`;
+	if (absolute.startsWith(prefix)) return absolute.slice(prefix.length);
+	const normalized = normalize(path.relative(rootDir, file));
+	return normalized === ".." || normalized.startsWith("../") ? void 0 : normalized;
+}
+function matchesDirectory(candidate, pattern) {
+	if (GLOB_TOKEN.test(pattern)) return false;
+	return candidate === pattern || candidate.startsWith(`${pattern}/`);
+}
+function matchesPattern(absolute, relative, rawPattern) {
+	const pattern = normalize(rawPattern);
+	const candidates = path.isAbsolute(pattern) || /^[A-Za-z]:\//u.test(pattern) ? [absolute] : relative === void 0 ? [] : [relative];
+	for (const candidate of candidates) if (matchesDirectory(candidate, pattern) || path.matchesGlob(candidate, pattern)) return true;
+	return false;
+}
+/** Whether one watcher path belongs to the checker include/exclude contract. */
+function matchesNuxtLintCheckerFile(file, rootDir, options) {
+	const absolute = normalize(file);
+	const relative = relativeToRoot(file, rootDir);
+	if (options.exclude.some((pattern) => matchesPattern(absolute, relative, pattern))) return false;
+	return options.include.some((pattern) => matchesPattern(absolute, relative, pattern));
+}
+//#endregion
+//#region src/lint/checker/worker.ts
+function resolveOxlintEntrypoint(cwd) {
+	try {
+		const manifest = createRequire(path.join(cwd, "package.json")).resolve("oxlint/package.json");
+		return path.join(path.dirname(manifest), "bin", "oxlint");
+	} catch (error) {
+		throw new Error(`Unable to resolve oxlint from ${cwd}. Install oxlint before enabling the Nuxt lint checker.`, { cause: error });
+	}
+}
+function projectPattern(pattern, cwd) {
+	if (!path.isAbsolute(pattern)) return pattern;
+	const relative = path.relative(cwd, pattern);
+	if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) return pattern;
+	return relative.split(path.sep).join("/") || ".";
+}
+function expandBraces(pattern) {
+	const match = /\{([^{}]+)\}/u.exec(pattern);
+	if (!match || match.index === void 0) return [pattern];
+	const before = pattern.slice(0, match.index);
+	const after = pattern.slice(match.index + match[0].length);
+	return match[1].split(",").flatMap((part) => expandBraces(`${before}${part}${after}`));
+}
+function oxlintPatterns(pattern, cwd) {
+	const patterns = expandBraces(projectPattern(pattern, cwd)).flatMap((expanded) => {
+		const shallow = expanded.replace(/(^|\/)\*\*\//gu, "$1");
+		return shallow === expanded ? [expanded] : [expanded, shallow];
+	});
+	return [...new Set(patterns)];
+}
+async function oxlintTargets(pattern, cwd) {
+	const rebased = projectPattern(pattern, cwd);
+	if (rebased.endsWith("/**/*.{js,jsx,ts,tsx,vue}")) return [rebased.slice(0, -25) || "."];
+	if (!/[*?[\]{}()]/u.test(rebased)) return [rebased];
+	const matches = await Array.fromAsync(glob(rebased, { cwd }));
+	return matches.length > 0 ? matches : oxlintPatterns(pattern, cwd);
+}
+async function checkerArgs(task) {
+	const args = [
+		"--config",
+		task.configFile,
+		"--format",
+		"json",
+		"--no-error-on-unmatched-pattern"
+	];
+	if (task.fix) args.push("--fix");
+	for (const pattern of task.exclude) for (const exclude of oxlintPatterns(pattern, task.cwd)) args.push("--ignore-pattern", exclude);
+	for (const target of task.targets) args.push(...await oxlintTargets(target, task.cwd));
+	return args;
+}
+function spawnOxlint(node, entrypoint, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(node, [entrypoint, ...args], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdout = [];
+		const stderr = [];
+		child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+		child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+		child.on("error", (error) => {
+			reject(new Error(`Failed to start oxlint at ${entrypoint}: ${error.message}`, { cause: error }));
+		});
+		child.on("close", (status) => {
+			const output = Buffer.concat(stdout).toString("utf8");
+			if (output.trim()) {
+				resolve(output);
+				return;
+			}
+			const details = Buffer.concat(stderr).toString("utf8").trim();
+			if (status === 0) {
+				resolve("{\"diagnostics\":[]}\n");
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`oxlint exited with ${String(status)} without JSON output${details ? `: ${details}` : ""}`));
+		});
+	});
+}
+async function executeOxlint(entrypoint, args, cwd) {
+	if (!existsSync(entrypoint)) throw new Error(`Failed to start oxlint: entrypoint does not exist: ${entrypoint}`);
+	const node = existsSync(process.execPath) ? process.execPath : "node";
+	try {
+		return await spawnOxlint(node, entrypoint, args, cwd);
+	} catch (error) {
+		const cause = error.cause;
+		if (node !== "node" && cause?.code === "ENOENT") return spawnOxlint("node", entrypoint, args, cwd);
+		throw error;
+	}
+}
+function diagnosticKind(diagnostic) {
+	if (diagnostic.severity === 2 || diagnostic.severity === "error") return "error";
+	if (diagnostic.severity === 1 || diagnostic.severity === "warn" || diagnostic.severity === "warning") return "warning";
+}
+function readableDiagnostics(diagnostics, formatter) {
+	const unix = formatter === "unix";
+	const lines = diagnostics.map((diagnostic) => {
+		const span = diagnostic.labels?.find((label) => label.span)?.span;
+		const file = diagnostic.filename ?? diagnostic.filePath ?? "<unknown>";
+		const line = span?.line ?? 1;
+		const column = span?.column ?? 1;
+		const severity = diagnosticKind(diagnostic) ?? "warning";
+		const message = diagnostic.message ?? "lint diagnostic";
+		const code = diagnostic.code ? ` (${diagnostic.code})` : "";
+		return unix ? `${file}:${line}:${column}: ${message} [${severity}${code}]` : `${file}:${line}:${column}  ${severity}  ${message}${code}`;
+	});
+	return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}
+function resultFromPayload(payload, task) {
+	const diagnostics = payload.diagnostics.filter((diagnostic) => {
+		const kind = diagnosticKind(diagnostic);
+		return kind === "error" && task.emitError || kind === "warning" && task.emitWarning;
+	});
+	const hasErrors = diagnostics.some((diagnostic) => diagnosticKind(diagnostic) === "error");
+	const hasWarnings = diagnostics.some((diagnostic) => diagnosticKind(diagnostic) === "warning");
+	const output = task.formatter === "json" ? diagnostics.length > 0 ? `${JSON.stringify({
+		...payload,
+		diagnostics
+	})}\n` : "" : readableDiagnostics(diagnostics, task.formatter);
+	return {
+		diagnosticCount: diagnostics.length,
+		hasErrors,
+		hasWarnings,
+		output
+	};
+}
+/** Run one checker pass. This function executes inside the long-lived worker. */
+async function runNuxtLintCheckerTask(task) {
+	if (!task.emitError && !task.emitWarning && !task.fix) return {
+		diagnosticCount: 0,
+		hasErrors: false,
+		hasWarnings: false,
+		output: ""
+	};
+	const stdout = await executeOxlint(task.oxlintEntrypoint ?? resolveOxlintEntrypoint(task.cwd), await checkerArgs(task), task.cwd);
+	let payload;
+	try {
+		payload = JSON.parse(stdout);
+	} catch (error) {
+		throw new Error(`oxlint returned invalid JSON: ${stdout.slice(0, 240)}`, { cause: error });
+	}
+	if (!Array.isArray(payload.diagnostics)) throw new Error("oxlint JSON has no diagnostics array");
+	return resultFromPayload(payload, task);
+}
+function serializeError(error) {
+	if (error instanceof Error) return {
+		message: error.message,
+		stack: error.stack
+	};
+	return { message: String(error) };
+}
+if (!isMainThread && parentPort) parentPort.on("message", async ({ id, task }) => {
+	try {
+		parentPort?.postMessage({
+			id,
+			result: await runNuxtLintCheckerTask(task)
+		});
+	} catch (error) {
+		parentPort?.postMessage({
+			error: serializeError(error),
+			id
+		});
+	}
+});
+/** Persistent worker-thread client used by the Vite dev plugin. */
+var NuxtLintCheckerWorker = class {
+	worker = new Worker(new URL(import.meta.url));
+	pending = /* @__PURE__ */ new Map();
+	nextId = 0;
+	closed = false;
+	constructor() {
+		this.worker.on("message", (response) => {
+			const pending = this.pending.get(response.id);
+			if (!pending) return;
+			this.pending.delete(response.id);
+			if ("error" in response) {
+				const error = new Error(response.error.message);
+				error.stack = response.error.stack ?? error.stack;
+				pending.reject(error);
+			} else pending.resolve(response.result);
+		});
+		this.worker.on("error", (error) => this.rejectAll(error));
+		this.worker.on("exit", (code) => {
+			if (!this.closed) this.rejectAll(/* @__PURE__ */ new Error(`Nuxt lint worker exited with ${code}`));
+		});
+	}
+	run(task) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Nuxt lint worker is closed"));
+		const id = ++this.nextId;
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				reject,
+				resolve
+			});
+			this.worker.postMessage({
+				id,
+				task
+			});
+		});
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.rejectAll(/* @__PURE__ */ new Error("Nuxt lint worker closed"));
+		await this.worker.terminate();
+	}
+	rejectAll(error) {
+		for (const pending of this.pending.values()) pending.reject(error);
+		this.pending.clear();
+	}
+};
+//#endregion
+//#region src/lint/checker/vite.ts
+const PLUGIN_NAME$1 = "vize:nuxt-lint-checker";
+function overlayError(output) {
+	return {
+		type: "error",
+		err: {
+			message: "Vize lint checker found diagnostics",
+			stack: output,
+			plugin: PLUGIN_NAME$1
+		}
+	};
+}
+var NuxtLintChangeCollector = class {
+	pendingFiles = /* @__PURE__ */ new Set();
+	pendingFull = false;
+	draining = false;
+	closed = false;
+	overlayVisible = false;
+	config;
+	runner;
+	server;
+	oxlintEntrypoint;
+	constructor(config, runner, server, oxlintEntrypoint) {
+		this.config = config;
+		this.runner = runner;
+		this.server = server;
+		this.oxlintEntrypoint = oxlintEntrypoint;
+	}
+	full() {
+		if (this.closed) return;
+		this.pendingFull = true;
+		this.pendingFiles.clear();
+		this.schedule();
+	}
+	file(file) {
+		if (this.closed) return;
+		if (path.resolve(file) === path.resolve(this.config.configFile)) {
+			this.full();
+			return;
+		}
+		if (!matchesNuxtLintCheckerFile(file, this.config.rootDir, this.config.options)) return;
+		if (!this.config.options.cache) {
+			this.full();
+			return;
+		}
+		if (!this.pendingFull) this.pendingFiles.add(path.resolve(file));
+		this.schedule();
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.pendingFiles.clear();
+		await this.runner.close();
+	}
+	schedule() {
+		if (this.draining) return;
+		this.draining = true;
+		queueMicrotask(() => void this.drain());
+	}
+	async drain() {
+		while (!this.closed && (this.pendingFull || this.pendingFiles.size > 0)) {
+			const targets = this.pendingFull ? [...this.config.options.include] : [...this.pendingFiles].sort();
+			this.pendingFull = false;
+			this.pendingFiles.clear();
+			try {
+				const result = await this.runner.run(this.task(targets));
+				if (!this.closed) this.report(result);
+			} catch (error) {
+				if (!this.closed) this.reportFailure(error);
+			}
+		}
+		this.draining = false;
+		if (!this.closed && (this.pendingFull || this.pendingFiles.size > 0)) this.schedule();
+	}
+	task(targets) {
+		const options = this.config.options;
+		return {
+			configFile: this.config.configFile,
+			cwd: this.config.rootDir,
+			emitError: options.emitError,
+			emitWarning: options.emitWarning,
+			exclude: [...options.exclude],
+			fix: options.fix,
+			formatter: options.formatter,
+			oxlintEntrypoint: this.oxlintEntrypoint,
+			targets
+		};
+	}
+	report(result) {
+		if (result.output) {
+			if (result.hasErrors) this.server.config.logger.error(result.output);
+			else if (result.hasWarnings) this.server.config.logger.warn(result.output);
+		}
+		if (result.diagnosticCount > 0) {
+			this.server.ws.send(overlayError(result.output));
+			this.overlayVisible = true;
+		} else if (this.overlayVisible) {
+			this.server.ws.send({
+				type: "update",
+				updates: []
+			});
+			this.overlayVisible = false;
+		}
+	}
+	reportFailure(error) {
+		const message = `Nuxt lint checker failed: ${error instanceof Error ? error.message : String(error)}`;
+		this.server.config.logger.error(message);
+		this.server.ws.send(overlayError(message));
+		this.overlayVisible = true;
+	}
+};
+/** Create the client-side Vite dev plugin; it has no transform/render hooks. */
+function createNuxtLintCheckerVitePlugin(config, dependencies = {}) {
+	return {
+		name: PLUGIN_NAME$1,
+		apply: "serve",
+		enforce: "post",
+		configureServer(server) {
+			const collector = new NuxtLintChangeCollector(config, dependencies.createRunner?.() ?? new NuxtLintCheckerWorker(), server, dependencies.oxlintEntrypoint);
+			server.watcher.add(config.configFile);
+			const changed = (file) => collector.file(file);
+			server.watcher.on("add", changed);
+			server.watcher.on("change", changed);
+			server.watcher.on("unlink", changed);
+			server.httpServer?.once("close", () => void collector.close());
+			if (config.options.lintOnStart) collector.full();
+		}
+	};
+}
+//#endregion
+//#region src/lint/checker/webpack.ts
+const PLUGIN_NAME = "VizeNuxtLintChecker";
+function checkerError(message) {
+	const error = new Error(message);
+	error.name = PLUGIN_NAME;
+	return error;
+}
+function reportResult(compilation, result) {
+	if (result.hasErrors) compilation.errors.push(checkerError(result.output));
+	else if (result.hasWarnings) compilation.warnings.push(checkerError(result.output));
+}
+function task(config, targets, oxlintEntrypoint) {
+	const options = config.options;
+	return {
+		configFile: config.configFile,
+		cwd: config.rootDir,
+		emitError: options.emitError,
+		emitWarning: options.emitWarning,
+		exclude: [...options.exclude],
+		fix: options.fix,
+		formatter: options.formatter,
+		oxlintEntrypoint,
+		targets
+	};
+}
+function changedTargets(compiler, config, initial) {
+	const modified = compiler.modifiedFiles;
+	if (initial && config.options.lintOnStart) return [...config.options.include];
+	if (!modified || modified.size === 0) return void 0;
+	if (!config.options.cache) return [...config.options.include];
+	const configFile = path.resolve(config.configFile);
+	if ([...modified].some((file) => path.resolve(file) === configFile)) return [...config.options.include];
+	const files = [...modified].filter((file) => matchesNuxtLintCheckerFile(file, config.rootDir, config.options)).map((file) => path.resolve(file)).sort();
+	return files.length > 0 ? files : void 0;
+}
+/**
+* Create Nuxt 2's webpack adapter.
+*
+* The worker starts at `watchRun`, concurrently with compilation; only the
+* final diagnostic handoff happens at `afterCompile`, where webpack can feed
+* the result to its existing terminal and browser overlays.
+*/
+function createNuxtLintCheckerWebpackPlugin(config, dependencies = {}) {
+	return { apply(compiler) {
+		const runner = dependencies.createRunner?.() ?? new NuxtLintCheckerWorker();
+		let initial = true;
+		let pending;
+		compiler.hooks.watchRun.tap(PLUGIN_NAME, (nextCompiler) => {
+			const targets = changedTargets(nextCompiler, config, initial);
+			initial = false;
+			pending = targets ? runner.run(task(config, targets, dependencies.oxlintEntrypoint)) : void 0;
+		});
+		compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, async (compilation) => {
+			compilation.fileDependencies.add(config.configFile);
+			if (!pending) return;
+			const current = pending;
+			pending = void 0;
+			try {
+				reportResult(compilation, await current);
+			} catch (error) {
+				compilation.errors.push(checkerError(`Nuxt lint checker failed: ${error instanceof Error ? error.message : String(error)}`));
+			}
+		});
+		compiler.hooks.watchClose.tap(PLUGIN_NAME, () => void runner.close());
+	} };
+}
+//#endregion
+//#region src/lint/checker/setup.ts
+async function addVitePlugin(plugin) {
+	(await import("@nuxt/kit")).addVitePlugin(plugin, { server: false });
+}
+async function addWebpackPlugin(plugin) {
+	(await import("@nuxt/kit")).addWebpackPlugin(plugin, { server: false });
+}
+function builderKind(builder) {
+	if (typeof builder !== "string") return "unsupported";
+	if (builder === "vite" || builder.includes("vite-builder")) return "vite";
+	if (builder === "webpack" || builder.includes("webpack-builder")) return "webpack";
+	return "unsupported";
+}
+/** Register the dev-only adapter over Phase 3's generated config artifact. */
+async function setupNuxtLintChecker(checker, nuxt, generation, dependencies = {}) {
+	if (checker !== true && (checker === false || checker == null)) return void 0;
+	if (nuxt.options.dev !== true) return void 0;
+	if (!generation) throw new Error("The Nuxt lint checker requires lint config generation; enable `vize.lint`.");
+	const options = resolveNuxtLintCheckerOptions(checker, {
+		buildDir: nuxt.options.buildDir,
+		srcDir: nuxt.options.srcDir ?? nuxt.options.rootDir
+	});
+	if (options === false) return void 0;
+	const rootDir = path.resolve(nuxt.options.rootDir);
+	const config = {
+		configFile: generation.configFile,
+		options,
+		rootDir
+	};
+	const builder = builderKind(nuxt.options.builder);
+	if (builder === "vite") await (dependencies.addVitePlugin ?? addVitePlugin)(createNuxtLintCheckerVitePlugin(config));
+	else if (builder === "webpack") await (dependencies.addWebpackPlugin ?? addWebpackPlugin)(createNuxtLintCheckerWebpackPlugin(config));
+	else {
+		const label = typeof nuxt.options.builder === "string" ? nuxt.options.builder : "unknown";
+		(dependencies.warn ?? console.warn)(`Unsupported Nuxt builder ${label}; Vize lint checker is disabled.`);
+	}
+	return {
+		builder,
+		configFile: generation.configFile,
+		options
+	};
+}
+//#endregion
+//#region src/lint/addons.ts
+/** Hook other Nuxt modules use to extend Vize's generated lint config. */
+const VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK = "vize:lint:config:addons";
+function asImportContext(value) {
+	if (value == null || typeof value !== "object" || !("getImports" in value)) return;
+	return typeof value.getImports === "function" ? value : void 0;
+}
+function nitroImportContext(value) {
+	if (value == null || typeof value !== "object" || !("unimport" in value)) return;
+	return asImportContext(value.unimport);
+}
+/**
+* Capture Nuxt's client and server auto-import registries as readonly globals.
+*
+* Nuxt publishes both contexts after modules have begun setting up. Keeping
+* their latest values in the addon means every config regeneration observes
+* the current registry rather than a module-setup-time snapshot.
+*/
+function createNuxtImportGlobalsAddon(nuxt) {
+	let unimport;
+	let nitroUnimport;
+	nuxt.hook("imports:context", (context) => {
+		unimport = asImportContext(context);
+	});
+	nuxt.hook("nitro:init", (nitro) => {
+		nitroUnimport = nitroImportContext(nitro);
+	});
+	return {
+		name: "vize:lint:import-globals",
+		async getConfigs() {
+			const imports = [...await unimport?.getImports() ?? [], ...await nitroUnimport?.getImports() ?? []].sort((left, right) => left.from.localeCompare(right.from) || left.name.localeCompare(right.name));
+			return [{
+				name: "nuxt/import-globals",
+				globals: Object.fromEntries(imports.map((imported) => [imported.as ?? imported.name, "readonly"]))
+			}];
+		}
+	};
+}
+/**
+* Register the built-in auto-import addon and return the generation-time
+* resolver consumed by the Nuxt lint config writer.
+*
+* The addon array is rebuilt for every generation. This mirrors Nuxt's addon
+* hook without retaining contributions across `builder:generateApp` runs.
+* The Vize-namespaced hook carries engine-neutral config items instead of raw
+* ESLint source, so contributors remain compatible with the oxlint emitter.
+*/
+function setupNuxtLintConfigAddons(nuxt) {
+	const defaults = [createNuxtImportGlobalsAddon(nuxt)];
+	return async () => {
+		const addons = [...defaults];
+		await nuxt.callHook(VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK, addons);
+		const configs = [];
+		for (const addon of addons) {
+			const contributed = await addon.getConfigs();
+			if (contributed) configs.push(...contributed);
+		}
+		return configs;
+	};
+}
+//#endregion
+//#region src/lint/emitter.ts
+const PATINA_RULE_NAMESPACES = new Set([
+	"a11y",
+	"css",
+	"ecosystem",
+	"html",
+	"musea",
+	"nuxt",
+	"petite-vue",
+	"script",
+	"ssr",
+	"type",
+	"vapor",
+	"vize",
+	"vue"
+]);
+function toOxlintRuleId(ruleId) {
+	const separator = ruleId.indexOf("/");
+	const namespace = separator < 0 ? ruleId : ruleId.slice(0, separator);
+	return PATINA_RULE_NAMESPACES.has(namespace) ? `vize/${ruleId}` : ruleId;
+}
+function prefixVizeRules(rules) {
+	if (!rules) return void 0;
+	return Object.fromEntries(Object.entries(rules).map(([ruleId, severity]) => [toOxlintRuleId(ruleId), severity]));
+}
+function mergeGlobals(target, source) {
+	if (!source) return;
+	for (const [name, access] of Object.entries(source)) Object.defineProperty(target, name, {
+		configurable: true,
+		enumerable: true,
+		value: access,
+		writable: true
+	});
+}
+function mergeRules(target, source) {
+	Object.assign(target, prefixVizeRules(source));
+}
+/** Render the complete generated oxlint config, including its trailing newline. */
+function renderNuxtOxlintConfig(items, pluginSpecifier) {
+	const ignorePatterns = [];
+	const globals = {};
+	const rules = {};
+	const overrides = [];
+	for (const item of items) {
+		if (item.files) {
+			const override = { files: [...item.files] };
+			if (item.ignores) override.excludeFiles = [...item.ignores];
+			if (item.globals) override.globals = { ...item.globals };
+			if (item.rules) override.rules = prefixVizeRules(item.rules);
+			overrides.push(override);
+			continue;
+		}
+		if (item.ignores) ignorePatterns.push(...item.ignores);
+		mergeGlobals(globals, item.globals);
+		mergeRules(rules, item.rules);
+	}
+	const config = {
+		plugins: ["vue"],
+		jsPlugins: [{
+			name: "vize",
+			specifier: pluginSpecifier
+		}],
+		settings: { vize: { preset: "incremental" } }
+	};
+	if (ignorePatterns.length > 0) config.ignorePatterns = ignorePatterns;
+	if (Object.keys(globals).length > 0) config.globals = globals;
+	if (Object.keys(rules).length > 0) config.rules = rules;
+	if (overrides.length > 0) config.overrides = overrides;
+	return `${JSON.stringify(config, null, 2)}\n`;
+}
+//#endregion
+//#region src/lint/nuxt-state.ts
+/**
+* Reduce a Nuxt instance to the project state lint config generation needs.
+*
+* Nuxt 2 has no `_layers`, so the project is treated as a single layer rooted
+* at `srcDir` (falling back to `rootDir`). That keeps the Nuxt 2, 3 and 4 paths
+* on one code path rather than branching on the detected major version.
+*/
+function toNuxtLintProjectState(options, overrides = {}) {
+	const rootDir = overrides.rootDir || options.rootDir;
+	const layers = (options._layers ?? []).map((layer) => layer.config).filter((config) => Boolean(config)).map((config) => ({
+		...config,
+		srcDir: config.srcDir || options.srcDir || options.rootDir
+	}));
+	return {
+		rootDir,
+		dir: options.dir ?? {},
+		layers: layers.length > 0 ? layers : [{ srcDir: options.srcDir || options.rootDir }]
+	};
+}
+//#endregion
+//#region src/lint/inspector-view.ts
+/** Render the dependency-free UI served by the in-process lint-plan inspector. */
+function renderNuxtLintInspectorHtml(nonce) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>Vize Nuxt Lint Plan</title>
+  <style nonce="${nonce}">
+    :root { color-scheme: light dark; font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; }
+    * { box-sizing: border-box; }
+    body { margin: 0; background: #0d1117; color: #e6edf3; }
+    header { position: sticky; top: 0; z-index: 1; padding: 16px 20px; background: #161b22; border-bottom: 1px solid #30363d; }
+    h1 { margin: 0 0 12px; font-size: 18px; }
+    h2 { margin: 24px 0 10px; font-size: 16px; }
+    form { display: flex; gap: 8px; flex-wrap: wrap; }
+    input { flex: 1 1 320px; min-width: 180px; padding: 8px 10px; color: inherit; background: #0d1117; border: 1px solid #484f58; border-radius: 6px; }
+    button { padding: 8px 12px; color: #fff; background: #238636; border: 0; border-radius: 6px; cursor: pointer; }
+    button.secondary { background: #30363d; }
+    button:disabled { opacity: .6; cursor: wait; }
+    main { max-width: 1100px; margin: 0 auto; padding: 0 20px 32px; }
+    #status { min-height: 22px; margin-top: 8px; color: #8c959f; }
+    #status.error { color: #ff7b72; }
+    .card { margin: 8px 0; padding: 12px; background: #161b22; border: 1px solid #30363d; border-radius: 8px; }
+    .meta { color: #8c959f; overflow-wrap: anywhere; }
+    .badge { display: inline-block; margin: 2px 4px 2px 0; padding: 1px 6px; border-radius: 10px; background: #30363d; }
+    .severity-error { color: #ff7b72; } .severity-warn { color: #d29922; } .severity-off { color: #8c959f; }
+    table { width: 100%; border-collapse: collapse; }
+    th, td { padding: 7px 8px; text-align: left; border-bottom: 1px solid #30363d; overflow-wrap: anywhere; }
+    th { color: #8c959f; font-weight: 600; }
+    code { font-family: ui-monospace, SFMono-Regular, Consolas, monospace; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Vize Nuxt Lint Plan</h1>
+    <form id="inspect-form">
+      <input id="file" name="file" autocomplete="off" placeholder="app/pages/index.vue" aria-label="Project-relative file">
+      <button type="submit">Inspect file</button>
+      <button id="refresh" class="secondary" type="button">Refresh plan</button>
+    </form>
+    <div id="status" role="status" aria-live="polite"></div>
+  </header>
+  <main>
+    <section><h2>Effective rules</h2><div id="effective"></div></section>
+    <section><h2>Ordered config items</h2><div id="items"></div></section>
+  </main>
+  <script nonce="${nonce}">
+    const fileInput = document.getElementById("file");
+    const form = document.getElementById("inspect-form");
+    const refresh = document.getElementById("refresh");
+    const status = document.getElementById("status");
+    const effective = document.getElementById("effective");
+    const items = document.getElementById("items");
+    const buttons = Array.from(document.querySelectorAll("button"));
+
+    function node(tag, text, className) {
+      const value = document.createElement(tag);
+      if (text !== undefined) value.textContent = String(text);
+      if (className) value.className = className;
+      return value;
+    }
+
+    function badges(values) {
+      const wrapper = node("div");
+      for (const value of values || []) wrapper.append(node("span", value, "badge"));
+      return wrapper;
+    }
+
+    function renderItems(payload) {
+      items.replaceChildren();
+      for (const item of payload.items || []) {
+        const card = node("article", undefined, "card");
+        card.append(node("strong", item.name || "unnamed"));
+        if (item.globalIgnore) card.append(node("span", " global ignore", "meta"));
+        if (item.basePath) card.append(node("div", "base: " + item.basePath, "meta"));
+        if (item.files) card.append(node("div", "files", "meta"), badges(item.files));
+        if (item.ignores && item.ignores.length) card.append(node("div", "ignores", "meta"), badges(item.ignores));
+        const rules = Object.entries(item.rules || {});
+        if (rules.length) card.append(badges(rules.map(([name, severity]) => name + ": " + severity)));
+        items.append(card);
+      }
+    }
+
+    function renderEffective(payload) {
+      effective.replaceChildren();
+      const file = payload.files && payload.files[0];
+      if (!file) {
+        effective.append(node("p", "Enter a project-relative file to explain its effective rules.", "meta"));
+        return;
+      }
+      const summary = node("div", undefined, "card");
+      summary.append(node("strong", file.path));
+      if (file.ignored) summary.append(node("div", "Ignored by: " + (file.ignoredBy || []).join(", "), "severity-warn"));
+      else summary.append(node("div", "Matched: " + (file.matchedItems || []).join(" → "), "meta"));
+      effective.append(summary);
+      if (!file.rules || !file.rules.length) return;
+      const table = node("table");
+      const head = node("tr");
+      for (const label of ["Rule", "Severity", "Set by"]) head.append(node("th", label));
+      const thead = node("thead"); thead.append(head); table.append(thead);
+      const tbody = node("tbody");
+      for (const rule of file.rules) {
+        const row = node("tr");
+        row.append(node("td", rule.name), node("td", rule.severity, "severity-" + rule.severity), node("td", rule.setBy));
+        tbody.append(row);
+      }
+      table.append(tbody); effective.append(table);
+    }
+
+    async function load(fresh) {
+      const url = new URL("api", location.href);
+      const file = fileInput.value.trim();
+      if (file) url.searchParams.set("file", file);
+      if (fresh) url.searchParams.set("fresh", "1");
+      buttons.forEach(button => { button.disabled = true; });
+      status.className = ""; status.textContent = fresh ? "Refreshing…" : "Loading…";
+      try {
+        const response = await fetch(url, { headers: { accept: "application/json" } });
+        const payload = await response.json();
+        if (!response.ok) throw new Error(payload.error || "Inspector request failed");
+        renderEffective(payload); renderItems(payload);
+        status.textContent = "Resolved " + (payload.items || []).length + " config items";
+      } catch (error) {
+        status.className = "error";
+        status.textContent = error instanceof Error ? error.message : String(error);
+      } finally {
+        buttons.forEach(button => { button.disabled = false; });
+      }
+    }
+
+    form.addEventListener("submit", event => { event.preventDefault(); void load(false); });
+    refresh.addEventListener("click", () => { void load(true); });
+    void load(false);
+  <\/script>
+</body>
+</html>`;
+}
+//#endregion
+//#region src/lint/inspector-devtools.ts
+const MAX_URL_BYTES = 8 * 1024;
+const MAX_FILES = 128;
+const MAX_FILE_BYTES = 4 * 1024;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+function resolveNuxtLintDevtoolsOptions(options) {
+	const enabled = options?.enabled ?? "lazy";
+	const port = options?.port;
+	if (port !== void 0 && (!Number.isInteger(port) || port < 1 || port > 65535)) throw new RangeError("Nuxt lint inspector port must be an integer from 1 to 65535");
+	return {
+		enabled,
+		port
+	};
+}
+async function setupNuxtLintDevtools(options, nuxt, provider) {
+	const resolved = resolveNuxtLintDevtoolsOptions(options);
+	if (resolved.enabled === false) return void 0;
+	const controller = createController(resolved.port, provider, nuxt);
+	nuxt.hook("devtools:customTabs", (...args) => {
+		args[0].push(controller.tab());
+	});
+	nuxt.hook("close", () => controller.close());
+	if (resolved.enabled === true) try {
+		await controller.start();
+	} catch (error) {
+		console.warn(`[vize] Nuxt lint inspector failed to start: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return controller;
+}
+function createController(requestedPort, provider, nuxt) {
+	const token = randomBytes(18).toString("base64url");
+	const nonce = randomBytes(18).toString("base64url");
+	const server = createServer((request, response) => {
+		handleRequest(request, response, provider, token, nonce, server);
+	});
+	let closed = false;
+	let startPromise;
+	let viewerUrl;
+	const start = async () => {
+		if (closed) throw new Error("Nuxt lint inspector is closed");
+		if (viewerUrl) return;
+		startPromise ||= listen(server, requestedPort).then(async (port) => {
+			viewerUrl = `http://127.0.0.1:${port}/${token}/`;
+			await nuxt.callHook?.("devtools:customTabs:refresh");
+		});
+		try {
+			await startPromise;
+		} catch (error) {
+			startPromise = void 0;
+			throw error;
+		}
+	};
+	return {
+		async close() {
+			closed = true;
+			try {
+				await startPromise;
+			} catch {}
+			if (!server.listening) return;
+			await new Promise((resolve, reject) => {
+				server.close((error) => error ? reject(error) : resolve());
+				server.closeAllConnections();
+			});
+			viewerUrl = void 0;
+			startPromise = void 0;
+		},
+		start,
+		tab() {
+			return {
+				name: "vize-nuxt-lint-plan",
+				title: "Vize Nuxt Lint Plan",
+				icon: "carbon:rule",
+				requireAuth: true,
+				view: viewerUrl ? {
+					type: "iframe",
+					src: viewerUrl,
+					persistent: true
+				} : {
+					type: "launch",
+					description: "Inspect the effective Vize lint rules for any Nuxt source file.",
+					actions: [{
+						label: "Launch",
+						pending: startPromise !== void 0,
+						handle: start
+					}]
+				}
+			};
+		},
+		url: () => viewerUrl
+	};
+}
+function listen(server, port) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve(server.address().port);
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen({
+			host: "127.0.0.1",
+			port: port ?? 0,
+			exclusive: true
+		});
+	});
+}
+async function handleRequest(request, response, provider, token, nonce, server) {
+	if (Buffer.byteLength(request.url ?? "") > MAX_URL_BYTES) {
+		sendJson(response, 414, { error: "request_uri_too_long" });
+		return;
+	}
+	const port = server.address()?.port;
+	if (!port || ![`127.0.0.1:${port}`, `localhost:${port}`].includes(request.headers.host ?? "")) {
+		sendJson(response, 421, { error: "misdirected_request" });
+		return;
+	}
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		response.setHeader("allow", "GET, HEAD");
+		sendJson(response, 405, { error: "method_not_allowed" });
+		return;
+	}
+	let url;
+	try {
+		url = new URL(request.url ?? "", "http://localhost");
+	} catch {
+		sendJson(response, 400, { error: "invalid_url" }, request.method === "HEAD");
+		return;
+	}
+	const rootPath = `/${token}/`;
+	if (url.pathname === rootPath && url.search === "") {
+		sendHtml(response, renderNuxtLintInspectorHtml(nonce), nonce, request.method === "HEAD");
+		return;
+	}
+	if (url.pathname !== `${rootPath}api`) {
+		sendJson(response, 404, { error: "not_found" }, request.method === "HEAD");
+		return;
+	}
+	const parsed = parseApiRequest(url);
+	if ("error" in parsed) {
+		sendJson(response, parsed.status, { error: parsed.error }, request.method === "HEAD");
+		return;
+	}
+	try {
+		sendJson(response, 200, await provider(parsed.request), request.method === "HEAD");
+	} catch {
+		sendJson(response, 500, { error: "inspector_lint_plan_failed" }, request.method === "HEAD");
+	}
+}
+function parseApiRequest(url) {
+	for (const key of url.searchParams.keys()) if (key !== "file" && key !== "fresh") return {
+		status: 400,
+		error: "invalid_query"
+	};
+	const fresh = url.searchParams.getAll("fresh");
+	if (fresh.length > 1 || fresh[0] !== void 0 && fresh[0] !== "1") return {
+		status: 400,
+		error: "invalid_fresh"
+	};
+	const requested = url.searchParams.getAll("file");
+	if (requested.length > MAX_FILES) return {
+		status: 413,
+		error: "too_many_files"
+	};
+	const files = [...new Set(requested)];
+	if (files.some((file) => !isSafeFile(file))) return {
+		status: 400,
+		error: "invalid_file"
+	};
+	return { request: {
+		files,
+		fresh: fresh[0] === "1"
+	} };
+}
+function isSafeFile(file) {
+	return file.length > 0 && Buffer.byteLength(file) <= MAX_FILE_BYTES && !file.includes("\0") && !file.includes("\\") && !file.startsWith("/") && !/^[A-Za-z]:/u.test(file) && !file.split("/").some((part) => part.length === 0 || part === "..");
+}
+function setCommonHeaders(response, resourcePolicy) {
+	response.setHeader("cache-control", "no-store");
+	response.setHeader("cross-origin-resource-policy", resourcePolicy);
+	response.setHeader("referrer-policy", "no-referrer");
+	response.setHeader("x-content-type-options", "nosniff");
+}
+function sendHtml(response, body, nonce, headOnly) {
+	response.statusCode = 200;
+	setCommonHeaders(response, "cross-origin");
+	response.setHeader("content-security-policy", `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; frame-ancestors http://localhost:* http://127.0.0.1:*`);
+	response.setHeader("content-type", "text/html; charset=utf-8");
+	response.setHeader("content-length", Buffer.byteLength(body));
+	response.end(headOnly ? void 0 : body);
+}
+function sendJson(response, status, payload, headOnly = false) {
+	let body = JSON.stringify(payload);
+	if (body === void 0) {
+		status = 500;
+		body = JSON.stringify({ error: "inspector_lint_plan_failed" });
+	}
+	if (Buffer.byteLength(body) > MAX_RESPONSE_BYTES) {
+		status = 413;
+		body = JSON.stringify({ error: "inspector_response_too_large" });
+	}
+	response.statusCode = status;
+	setCommonHeaders(response, "same-origin");
+	response.setHeader("content-security-policy", "default-src 'none'");
+	response.setHeader("content-type", "application/json; charset=utf-8");
+	response.setHeader("content-length", Buffer.byteLength(body));
+	response.end(headOnly ? void 0 : body);
+}
+//#endregion
+//#region src/lint/inspector.ts
+function createNuxtLintInspectorProvider(generation, dependencies = {}) {
+	const inspect = dependencies.inspectLintPlan ?? inspectWithNative;
+	return async (request) => {
+		const items = await generation.resolvePlan(request.fresh);
+		const serialized = await inspect(JSON.stringify({ items }), generation.root, request.files);
+		const payload = JSON.parse(serialized);
+		if (!isLintPlanPayload(payload)) throw new Error("Native lint-plan inspector returned an invalid payload");
+		return payload;
+	};
+}
+async function setupLintInspector(lint, nuxt, compiler, generation, enabled) {
+	if (enabled === false || !generation) return;
+	const provider = createNuxtLintInspectorProvider(generation);
+	if (compiler !== false) {
+		compiler.inspector ||= {};
+		compiler.inspector.lintPlan ||= provider;
+	}
+	await setupNuxtLintDevtools(typeof lint === "object" && lint !== null ? lint.devtools : void 0, nuxt, compiler === false ? provider : compiler.inspector.lintPlan);
+}
+async function inspectWithNative(plan, root, files) {
+	const { inspectLintPlan } = await import("@vizejs/native");
+	return inspectLintPlan(plan, root, files);
+}
+function isLintPlanPayload(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && value.schema === "vize.inspector.lint-plan" && value.version === 1 && typeof value.root === "string" && Array.isArray(value.items) && Array.isArray(value.files);
+}
+//#endregion
+//#region src/lint/generation.ts
+/** Nuxt module wiring for generated oxlint configuration. */
+const GENERATED_CONFIG_NAME = "oxlint.config.json";
+/** Root config names supported by oxlint's config discovery. */
+const ROOT_OXLINT_CONFIG_NAMES = [
+	".oxlintrc.json",
+	".oxlintrc.jsonc",
+	"oxlint.config.ts",
+	"oxlint.config.mts"
+];
+function isNotFound(error) {
+	return error.code === "ENOENT";
+}
+/**
+* Write bytes only when they differ from the current regular file.
+*
+* The length fast path mirrors Canon's materializer. A full byte comparison is
+* still required before skipping so equal-size edits are never mistaken for a
+* cache hit. Symlinks are rejected instead of followed.
+*/
+async function writeFileIfChanged(file, content) {
+	await mkdir(path.dirname(file), { recursive: true });
+	try {
+		const metadata = await lstat(file);
+		if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error(`Generated oxlint config must be a regular file: ${file}`);
+		if (metadata.size === Buffer.byteLength(content)) {
+			if ((await readFile(file)).equals(Buffer.from(content))) return false;
+		}
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, content, { flag: "wx" });
+		await rename(temporary, file);
+	} finally {
+		await unlink(temporary).catch((error) => {
+			if (!isNotFound(error)) throw error;
+		});
+	}
+	return true;
+}
+function hasTypeScript(rootDir) {
+	try {
+		createRequire(path.join(rootDir, "package.json")).resolve("typescript");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function relativeSpecifier(from, target) {
+	const relative = path.relative(from, target);
+	if (path.isAbsolute(relative)) return pathToFileURL(target).href;
+	const normalized = relative.split(path.sep).join("/");
+	return normalized.startsWith("./") || normalized.startsWith("../") ? normalized : `./${normalized}`;
+}
+function resolveVizePluginSpecifier(configDir) {
+	return relativeSpecifier(configDir, fileURLToPath(import.meta.resolve("oxlint-plugin-vize")));
+}
+async function findRootOxlintConfig(rootDir) {
+	let directory = path.resolve(rootDir);
+	while (true) {
+		for (const name of ROOT_OXLINT_CONFIG_NAMES) {
+			const candidate = path.join(directory, name);
+			try {
+				const metadata = await lstat(candidate);
+				if (metadata.isFile() || metadata.isSymbolicLink()) return candidate;
+			} catch (error) {
+				if (!isNotFound(error)) throw error;
+			}
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function renderRootOxlintConfig(rootDir, generatedConfig) {
+	const specifier = relativeSpecifier(rootDir, generatedConfig);
+	return [
+		"// Generated by @vizejs/nuxt.",
+		"import { readFileSync } from \"node:fs\";",
+		"",
+		"type OxlintJsPlugin = string | { name?: string; specifier: string };",
+		"",
+		`const generatedUrl = new URL(${JSON.stringify(specifier)}, import.meta.url);`,
+		"const config = JSON.parse(readFileSync(generatedUrl, \"utf8\"));",
+		"config.jsPlugins = config.jsPlugins.map((plugin: OxlintJsPlugin) =>",
+		"  typeof plugin === \"string\"",
+		"    ? new URL(plugin, generatedUrl).href",
+		"    : { ...plugin, specifier: new URL(plugin.specifier, generatedUrl).href },",
+		");",
+		"",
+		"export default config;",
+		""
+	].join("\n");
+}
+async function initRootOxlintConfig(rootDir, generatedConfig) {
+	if (await findRootOxlintConfig(rootDir)) return;
+	const handle = await open(path.join(rootDir, "oxlint.config.mts"), "wx").catch((error) => {
+		if (error.code === "EEXIST") return void 0;
+		throw error;
+	});
+	if (!handle) return;
+	try {
+		await handle.writeFile(renderRootOxlintConfig(rootDir, generatedConfig), "utf8");
+	} finally {
+		await handle.close();
+	}
+}
+/**
+* Generate the initial config and register the Nuxt regeneration hook.
+*
+* Addons are resolved inside `regenerate`, not at setup time, so Nuxt's import
+* registry and third-party module hooks can change between generateApp passes.
+*/
+async function setupNuxtLintConfigGeneration(lint, nuxt, dependencies = {}) {
+	if (lint === false) return void 0;
+	const { autoInit = true, configFile: configuredFile, rootDir: configuredRoot, ...featureOptions } = typeof lint === "object" && lint !== null ? lint : {};
+	const nuxtRoot = path.resolve(nuxt.options.rootDir);
+	const planRoot = configuredRoot ? path.resolve(nuxtRoot, configuredRoot) : nuxtRoot;
+	const configFile = path.resolve(nuxtRoot, configuredFile ?? path.join(nuxt.options.buildDir, GENERATED_CONFIG_NAME));
+	const hasTypeScriptProbe = dependencies.hasTypeScript ?? hasTypeScript;
+	const resolvePluginSpecifier = dependencies.resolvePluginSpecifier ?? resolveVizePluginSpecifier;
+	const resolveAddons = dependencies.resolveAddons ?? ("callHook" in nuxt ? setupNuxtLintConfigAddons(nuxt) : void 0);
+	let currentPlan = [];
+	const regenerate = async () => {
+		const plan = buildNuxtLintPlan(resolveNuxtLintFeatures(featureOptions, () => hasTypeScriptProbe(planRoot)), collectNuxtLintDirs(toNuxtLintProjectState(nuxt.options, { rootDir: planRoot })));
+		const addons = await resolveAddons?.() ?? [];
+		const nextPlan = [...plan, ...addons];
+		const changed = await writeFileIfChanged(configFile, renderNuxtOxlintConfig(nextPlan, resolvePluginSpecifier(path.dirname(configFile))));
+		currentPlan = nextPlan;
+		return changed;
+	};
+	const resolvePlan = async (fresh = false) => {
+		if (fresh) await regenerate();
+		return currentPlan;
+	};
+	await regenerate();
+	nuxt.hook("builder:generateApp", regenerate);
+	if (autoInit) await initRootOxlintConfig(nuxtRoot, configFile);
+	return {
+		configFile,
+		root: planRoot,
+		regenerate,
+		resolvePlan
+	};
+}
+//#endregion
+export { toNuxtLintProjectState as a, setupNuxtLintConfigAddons as c, createNuxtLintCheckerVitePlugin as d, resolveNuxtLintCheckerOptions as f, setupLintInspector as i, setupNuxtLintChecker as l, setupNuxtLintConfigGeneration as n, renderNuxtOxlintConfig as o, writeFileIfChanged as r, VIZE_NUXT_LINT_CONFIG_ADDONS_HOOK as s, ROOT_OXLINT_CONFIG_NAMES as t, createNuxtLintCheckerWebpackPlugin as u };