oxlint-plugin-vize 0.435.0 → 0.439.0

package/dist/cli.mjs

@@ -1,8 +1,10 @@
-import { i as hasVueLikeExtension, s as isStandaloneHtmlFile, t as appendScriptlessWorkaround } from "./workaround-CcnA_oWy.mjs";
+import { n as prepareWorkaroundSource, p as isStandaloneHtmlFile, u as hasVueLikeExtension } from "./workaround-r91ttnV_.mjs";
 import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
 import fs from "node:fs";
+import { randomUUID } from "node:crypto";
 import os from "node:os";
+import { pathToFileURL } from "node:url";
 //#region src/cli/args.ts
 const OPTION_NAMES_WITH_VALUES = new Set([
 	"-A",
@@ -242,6 +244,101 @@ function escapeJsonStringSegment(value) {
 	return JSON.stringify(value).slice(1, -1);
 }
 //#endregion
+//#region src/cli/locations.ts
+/** Restore ranges before temporary filenames are replaced or files are removed. */
+function rewriteReportedLocations(output, locations) {
+	if (locations.size === 0 || output === "") return output;
+	let report;
+	try {
+		report = JSON.parse(output);
+	} catch {
+		return rewriteTextLocations(output, locations);
+	}
+	if (report == null || !Array.isArray(report.diagnostics)) return output;
+	const spans = report.diagnostics.flatMap((diagnostic) => (diagnostic.labels ?? []).map((label) => ({
+		original: label.span,
+		mapped: mapSpan(label.span, locations.get(diagnostic.filename ?? ""))
+	})));
+	let index = 0;
+	const rewritten = output.replace(/"span"\s*:\s*(\{[^{}]*\})/gu, (whole, raw) => {
+		const span = spans[index++];
+		if (span == null || JSON.stringify(JSON.parse(raw)) !== JSON.stringify(span.original)) throw new Error("Oxlint JSON label ownership changed; refusing a partial range rewrite.");
+		const mapped = span.mapped;
+		if (mapped == null) return whole;
+		return whole.replace(/("(offset|length|line|column)"\s*:\s*)\d+/gu, (_value, prefix, key) => `${prefix}${mapped[key]}`);
+	});
+	if (index !== spans.length) throw new Error("Oxlint JSON labels could not all be bound to their reported spans.");
+	return rewritten;
+}
+function mapSpan(span, map) {
+	if (map == null) return void 0;
+	const start = originalIndex(span.offset, map);
+	const end = originalIndex(span.offset + span.length, map);
+	if (start == null || end == null || end < start) return void 0;
+	const before = map.source.slice(0, start);
+	return {
+		offset: Buffer.byteLength(before, "utf8"),
+		length: Buffer.byteLength(map.source.slice(start, end), "utf8"),
+		line: before.split("\n").length,
+		column: start - before.lastIndexOf("\n")
+	};
+}
+function originalIndex(offset, map) {
+	if (!Number.isSafeInteger(offset) || offset < 0) return void 0;
+	if (offset >= map.scriptStart && offset <= map.scriptStart + map.source.length) {
+		const index = offset - map.scriptStart;
+		const previous = map.source.charCodeAt(index - 1);
+		const current = map.source.charCodeAt(index);
+		if (previous >= 55296 && previous <= 56319 && current >= 56320 && current <= 57343) return void 0;
+		return index;
+	}
+	const relative = offset - map.originalStart;
+	const bytes = Buffer.from(map.source, "utf8");
+	if (relative < 0 || relative > bytes.length) return void 0;
+	const before = bytes.subarray(0, relative).toString("utf8");
+	if (!Buffer.from(before, "utf8").equals(bytes.subarray(0, relative))) return void 0;
+	return before.length;
+}
+function rewriteTextLocations(output, locations) {
+	let active;
+	const ansi = String.raw`\u001B\[[0-9;]*m`;
+	const colors = new RegExp(ansi, "gu");
+	const stylishRow = new RegExp(String.raw`^(\s+(?:${ansi})*)(\d+):(\d+)((?:${ansi})*\s+(?:${ansi}|\s)*(?:error|warning)(?:${ansi})*\s+.*)$`, "u");
+	return output.split("\n").map((line) => {
+		if (line !== "" && line.trimStart() === line) active = locations.get(line.replace(colors, ""));
+		const frame = /^(.*╭─\[)(.*):(\d+):(\d+)(\].*)$/u.exec(line);
+		if (frame != null) {
+			const owner = frame[2].replace(colors, "");
+			const map = locations.get(owner);
+			const mapped = map == null ? void 0 : textPosition(Number(frame[3]), Number(frame[4]), map);
+			if (mapped != null) return `${frame[1]}${frame[2]}:${mapped.line}:${mapped.column}${frame[5]}`;
+		}
+		const stylish = stylishRow.exec(line);
+		if (stylish != null && active != null) {
+			const mapped = textPosition(Number(stylish[2]), Number(stylish[3]), active);
+			if (mapped != null) return `${stylish[1]}${mapped.line}:${mapped.column}${stylish[4]}`;
+		}
+		const plain = /^(.*?):(\d+):(\d+)(: )/u.exec(line);
+		const map = plain == null ? void 0 : locations.get(plain[1]);
+		if (plain != null && map != null) {
+			const mapped = textPosition(Number(plain[2]), Number(plain[3]), map);
+			if (mapped != null) return `${plain[1]}:${mapped.line}:${mapped.column}${plain[4]}${line.slice(plain[0].length)}`;
+		}
+		return line;
+	}).join("\n");
+}
+function textPosition(line, column, map) {
+	const lines = map.source.split("\n");
+	const originalLine = lines.length + 1;
+	const mappedLine = line >= originalLine ? line - originalLine + 1 : line;
+	const mappedColumn = line === 1 ? column - map.scriptStart : column;
+	if (mappedLine < 1 || mappedLine > lines.length || mappedColumn < 1 || mappedColumn > lines[mappedLine - 1].length + 1) return void 0;
+	return {
+		line: mappedLine,
+		column: mappedColumn
+	};
+}
+//#endregion
 //#region src/cli/workaround-files.ts
 function prepareScriptlessWorkaroundFiles(cwd, filenames) {
 	const nodeModulesDir = path.join(cwd, "node_modules");
@@ -251,6 +348,7 @@ function prepareScriptlessWorkaroundFiles(cwd, filenames) {
 	const ignoreArgs = [];
 	const tempArgs = [];
 	const pathReplacements = /* @__PURE__ */ new Map();
+	const locations = /* @__PURE__ */ new Map();
 	let counter = 0;
 	for (const filename of filenames) {
 		const source = fs.readFileSync(filename, "utf8");
@@ -265,10 +363,12 @@ function prepareScriptlessWorkaroundFiles(cwd, filenames) {
 		const tempFilename = path.join(tempDir, `${counter}-${tempBasename}`);
 		counter += 1;
 		fs.mkdirSync(path.dirname(tempFilename), { recursive: true });
-		fs.writeFileSync(tempFilename, appendScriptlessWorkaround(source, filename));
+		const bridge = prepareWorkaroundSource(source, filename);
+		fs.writeFileSync(tempFilename, bridge.source);
 		ignoreArgs.push("--ignore-pattern", toCliPath$1(relativeFilename));
 		tempArgs.push(tempFilename);
 		registerPathReplacementVariants(pathReplacements, cwd, tempFilename, filename);
+		registerLocationVariants(locations, cwd, tempFilename, bridge.locations);
 	}
 	return {
 		appendedArgs: [...ignoreArgs, ...tempArgs],
@@ -283,9 +383,18 @@ function prepareScriptlessWorkaroundFiles(cwd, filenames) {
 			if (createdNodeModules) removeEmptyDirectory(nodeModulesDir);
 		},
 		pathReplacements,
+		locations,
 		usedScriptlessWorkaround: pathReplacements.size > 0
 	};
 }
+function registerLocationVariants(locations, cwd, filename, map) {
+	for (const name of [
+		filename,
+		toCliPath$1(filename),
+		path.relative(cwd, filename),
+		toCliPath$1(path.relative(cwd, filename))
+	]) locations.set(name, map);
+}
 function createWorkaroundTempDir(nodeModulesDir, tempRoot) {
 	const createdNodeModules = !fs.existsSync(nodeModulesDir);
 	fs.mkdirSync(tempRoot, { recursive: true });
@@ -328,38 +437,90 @@ function getReportedOriginalFilename(cwd, filename) {
 }
 //#endregion
 //#region src/cli/scoped-config.ts
+const CONFIG_NAMES = [
+	".oxlintrc.json",
+	".oxlintrc.jsonc",
+	"oxlint.config.ts",
+	"oxlint.config.mts"
+];
 function readScopedConfig(cwd, args) {
 	let file;
 	for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-c" || args[index] === "--config") file = args[++index];
 	else if (args[index].startsWith("--config=")) file = args[index].slice(9);
-	if (file == null || !file.endsWith(".json")) return void 0;
+	const discovered = file == null;
+	if (discovered) {
+		const found = CONFIG_NAMES.filter((name) => fs.existsSync(path.join(cwd, name)));
+		if (found.length !== 1) return void 0;
+		file = found[0];
+	}
+	if (file == null) return void 0;
+	const module = /\.(?:m?ts)$/u.test(file);
+	if (!module && !file.endsWith(".json")) return void 0;
 	file = path.resolve(cwd, file);
 	const bytes = fs.readFileSync(file, "utf8");
+	if (!fs.lstatSync(file).isFile() || fs.lstatSync(file).isSymbolicLink()) throw new Error(`Scoped Vue transport requires a regular config: ${file}`);
+	if (module) return {
+		file,
+		bytes,
+		value: {},
+		module: true,
+		discovered
+	};
 	let value;
 	try {
 		value = JSON.parse(bytes);
 	} catch {
 		return;
 	}
-	if (!isRecord(value) || value.ignorePatterns == null && value.overrides == null) return void 0;
-	if (!fs.lstatSync(file).isFile() || fs.lstatSync(file).isSymbolicLink()) throw new Error(`Scoped Vue transport requires a regular JSON config: ${file}`);
+	if (!isRecord$1(value)) return void 0;
 	return {
 		file,
 		bytes,
+		value,
+		discovered
+	};
+}
+/** Match Oxlint's native Node import and JSON serialization of TS config objects. */
+async function loadScopedConfig(config) {
+	if (!config.module) return config;
+	const loaded = await import(pathToFileURL(config.file).href);
+	if (!isRecord$1(loaded.default)) throw new Error("Scoped Vue transport requires a default config object.");
+	const value = JSON.parse(JSON.stringify(loaded.default));
+	if (!isRecord$1(value)) throw new Error("Scoped Vue transport requires a serializable config object.");
+	return {
+		...config,
 		value
 	};
 }
+function validateNestedConfigs(config, files) {
+	if (!config.discovered) return;
+	const root = path.dirname(config.file);
+	for (const file of files) {
+		let directory = path.dirname(file);
+		while (contains(root, directory) && directory !== root) {
+			if (CONFIG_NAMES.some((name) => fs.existsSync(path.join(directory, name)))) throw new Error("Scoped Vue transport cannot preserve nested configuration files; use an explicit config.");
+			directory = path.dirname(directory);
+		}
+	}
+}
 function validateScopedConfig(config, args) {
 	const value = config.value;
 	if (path.parse(config.file).root !== "/") throw new Error("Scoped Vue transport cannot preserve non-POSIX filesystem roots.");
-	if (value.extends != null && (!Array.isArray(value.extends) || value.extends.length !== 0)) throw new Error("Scoped Vue transport cannot preserve inherited configs; use a complete JSON config.");
+	if (!config.module && value.extends != null && (!Array.isArray(value.extends) || value.extends.length !== 0)) throw new Error("Scoped Vue transport cannot preserve inherited configs; use a complete JSON config.");
+	if (config.module && value.extends != null) {
+		if (!Array.isArray(value.extends) || value.extends.some((parent) => !isRecord$1(parent))) throw new Error("Scoped Vue transport requires config objects in TypeScript extends.");
+		for (const parent of value.extends) validateScopedConfig({
+			...config,
+			value: parent
+		}, args);
+	}
 	if (args.includes("--cwd") || args.some((arg) => arg.startsWith("--cwd="))) throw new Error("Scoped Vue transport requires the process cwd; remove --cwd.");
 	if (args.some((arg) => [
 		"--type-aware",
 		"--type-check",
 		"--type-check-only"
-	].includes(arg)) || isRecord(value.options) && (value.options.typeAware || value.options.typeCheck)) throw new Error("Scoped Vue transport cannot preserve Oxlint's type-aware project graph.");
-	if (args.some((arg) => ["--import-plugin", "--tsconfig"].includes(arg) || arg.startsWith("--import-plugin=") || arg.startsWith("--tsconfig=")) || Array.isArray(value.plugins) && value.plugins.includes("import") || Array.isArray(value.overrides) && value.overrides.some((row) => isRecord(row) && Array.isArray(row.plugins) && row.plugins.includes("import"))) throw new Error("Scoped Vue transport cannot preserve Oxlint's import/project resolution.");
+	].includes(arg)) || isRecord$1(value.options) && (value.options.typeAware || value.options.typeCheck)) throw new Error("Scoped Vue transport cannot preserve Oxlint's type-aware project graph.");
+	if (args.some((arg) => ["--import-plugin", "--tsconfig"].includes(arg) || arg.startsWith("--import-plugin=") || arg.startsWith("--tsconfig=")) || Array.isArray(value.plugins) && value.plugins.includes("import") || Array.isArray(value.overrides) && value.overrides.some((row) => isRecord$1(row) && Array.isArray(row.plugins) && row.plugins.includes("import"))) throw new Error("Scoped Vue transport cannot preserve Oxlint's import/project resolution.");
 }
 function validateSelectionPaths(cwd, candidates) {
 	if (/[\r\n\\]/u.test(cwd) || [...candidates].some((file) => /[\r\n\\]/u.test(file))) throw new Error("Scoped Vue transport cannot preserve filenames containing CR, LF or backslash.");
@@ -368,7 +529,7 @@ function validateSelectionPaths(cwd, candidates) {
 function createScopedMirror(cwd, config, files) {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "oxlint-vize-"));
 	const configDir = path.dirname(config.file);
-	const sibling = path.join(configDir, `${path.basename(root)}.json`);
+	const sibling = path.join(configDir, `${path.basename(root)}.${config.module ? "mts" : "json"}`);
 	let ownsSibling = false;
 	const cleanup = () => {
 		try {
@@ -384,6 +545,7 @@ function createScopedMirror(cwd, config, files) {
 		if (contains(configDir, root) || contains(cwd, root)) throw new Error("Scoped Vue transport requires a temporary directory outside the lint/config roots.");
 		const originalsToCopies = /* @__PURE__ */ new Map();
 		const pathReplacements = /* @__PURE__ */ new Map();
+		const locations = /* @__PURE__ */ new Map();
 		for (const file of files) {
 			if (isStandaloneHtmlFile(file)) throw new Error("Scoped Vue transport requires .vue targets; HTML filtering is not equivalent.");
 			const relative = path.relative(configDir, file);
@@ -391,9 +553,11 @@ function createScopedMirror(cwd, config, files) {
 			if (path.parse(file).root !== path.parse(configDir).root) throw new Error("Scoped Vue transport cannot preserve files on another filesystem root.");
 			const source = fs.readFileSync(file, "utf8");
 			fs.mkdirSync(path.dirname(copy), { recursive: true });
-			fs.writeFileSync(copy, appendScriptlessWorkaround(source, file), { flag: "wx" });
+			const bridge = prepareWorkaroundSource(source, file);
+			fs.writeFileSync(copy, bridge.source, { flag: "wx" });
 			originalsToCopies.set(file, copy);
 			registerPathReplacementVariants(pathReplacements, cwd, copy, file);
+			registerLocationVariants(locations, cwd, copy, bridge.locations);
 		}
 		const copyPatterns = [...originalsToCopies.values()].map(literalGlob);
 		const outside = [...originalsToCopies].filter(([file]) => !contains(configDir, file));
@@ -412,28 +576,32 @@ function createScopedMirror(cwd, config, files) {
 				throw new Error(`Scoped Vue transport cannot preserve outside-root override pattern: ${pattern}`);
 			});
 		};
-		const overrides = config.value.overrides;
-		if (overrides != null && !Array.isArray(overrides)) throw new Error("Scoped Vue transport requires an override array.");
-		const borrowed = {
-			...config.value,
-			overrides: (overrides ?? []).flatMap((row) => {
-				if (!isRecord(row)) throw new Error("Scoped Vue transport requires object overrides.");
-				const files = mapPatterns(row.files);
-				const excludes = row.excludeFiles == null ? [] : mapPatterns(row.excludeFiles);
-				return [{
-					...row,
-					excludeFiles: [...strings(row.excludeFiles), ...copyPatterns]
-				}, {
-					...row,
-					files,
-					...excludes.length ? { excludeFiles: excludes } : { excludeFiles: [] }
-				}];
-			})
+		const project = (value) => {
+			const overrides = value.overrides;
+			if (overrides != null && !Array.isArray(overrides)) throw new Error("Scoped Vue transport requires an override array.");
+			return {
+				...value,
+				...config.module && Array.isArray(value.extends) ? { extends: value.extends.map((parent) => project(parent)) } : {},
+				overrides: (overrides ?? []).flatMap((row) => {
+					if (!isRecord$1(row)) throw new Error("Scoped Vue transport requires object overrides.");
+					const files = mapPatterns(row.files);
+					const excludes = row.excludeFiles == null ? [] : mapPatterns(row.excludeFiles);
+					return [{
+						...row,
+						excludeFiles: [...strings(row.excludeFiles), ...copyPatterns]
+					}, {
+						...row,
+						files,
+						...excludes.length ? { excludeFiles: excludes } : { excludeFiles: [] }
+					}];
+				})
+			};
 		};
+		const borrowed = project(config.value);
 		const descriptor = fs.openSync(sibling, "wx");
 		ownsSibling = true;
 		try {
-			fs.writeFileSync(descriptor, `${JSON.stringify(borrowed, null, 2)}\n`);
+			fs.writeFileSync(descriptor, `${config.module ? "export default " : ""}${JSON.stringify(borrowed, null, 2)}${config.module ? ";" : ""}\n`);
 		} finally {
 			fs.closeSync(descriptor);
 		}
@@ -442,6 +610,7 @@ function createScopedMirror(cwd, config, files) {
 			sibling,
 			originalsToCopies,
 			pathReplacements,
+			locations,
 			cleanup
 		};
 	} catch (error) {
@@ -449,7 +618,7 @@ function createScopedMirror(cwd, config, files) {
 		throw error;
 	}
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value != null && !Array.isArray(value);
 }
 function strings(value) {
@@ -468,11 +637,275 @@ function literalGlob(file) {
 	return toCliPath(file).replaceAll(/[\\*?[\]{}]/gu, String.raw`\$&`);
 }
 //#endregion
+//#region src/cli/project-checks.ts
+const isRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+const isVize = (name) => name.startsWith("vize/");
+/** Native/project checks retain original paths; only Vize executes on the bridge. */
+function splitProjectConfig(config) {
+	const visit = (value, bridge, override = false) => ({
+		...value,
+		...Array.isArray(value.extends) ? { extends: value.extends.map((parent) => visit(parent, bridge)) } : {},
+		...Array.isArray(value.overrides) ? { overrides: value.overrides.map((row) => visit(row, bridge, true)) } : {},
+		rules: Object.fromEntries(Object.entries(isRecord(value.rules) ? value.rules : {}).flatMap(([name, setting]) => bridge ? isVize(name) ? [[name, setting]] : [] : [[name, isVize(name) ? "off" : setting]])),
+		...bridge ? {
+			plugins: [],
+			...!override ? { categories: Object.fromEntries(["correctness", ...Object.keys(isRecord(value.categories) ? value.categories : {})].map((category) => [category, "off"])) } : {},
+			...isRecord(value.options) ? { options: {
+				...value.options,
+				typeAware: false,
+				typeCheck: false
+			} } : {}
+		} : {}
+	});
+	return {
+		original: {
+			...config,
+			value: visit(config.value, false)
+		},
+		bridge: {
+			...config,
+			value: visit(config.value, true)
+		}
+	};
+}
+function replaceConfigArgs(options, file) {
+	const args = [...options];
+	let replaced = false;
+	for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-c" || args[index] === "--config") {
+		args[++index] = file;
+		replaced = true;
+	} else if (args[index].startsWith("--config=")) {
+		args[index] = `--config=${file}`;
+		replaced = true;
+	}
+	if (!replaced) args.unshift("--config", file);
+	return args;
+}
+function bridgeProjectArgs(options) {
+	if (options.some((arg) => [
+		"-A",
+		"-D",
+		"-W",
+		"--allow",
+		"--deny",
+		"--warn",
+		"--max-warnings",
+		"--type-check-only",
+		"--report-unused-disable-directives",
+		"--report-unused-disable-directives-severity",
+		"--fix",
+		"--fix-suggestions",
+		"--fix-dangerously"
+	].includes(arg) || /^(?:--allow|--deny|--warn|--max-warnings|--report-unused-disable-directives-severity)=/u.test(arg))) throw new Error("Original-path project checks require rule severity in the config; remove CLI severity/limit overrides and fix flags, and unused-disable reporting.");
+	const args = [];
+	for (let index = 0; index < options.length; index += 1) {
+		const arg = options[index];
+		if (arg === "--tsconfig") index += 1;
+		else if (![
+			"--import-plugin",
+			"--type-aware",
+			"--type-check"
+		].includes(arg) && !arg.startsWith("--tsconfig=")) args.push(arg);
+	}
+	return args;
+}
+function writeOriginalProjectConfig(config) {
+	const file = path.join(path.dirname(config.file), `oxlint-vize-original-${randomUUID()}.${config.module ? "mts" : "json"}`);
+	fs.writeFileSync(file, `${config.module ? "export default " : ""}${JSON.stringify(config.value)}${config.module ? ";" : ""}\n`, { flag: "wx" });
+	return {
+		file,
+		cleanup: () => fs.unlinkSync(file)
+	};
+}
+//#endregion
+//#region src/cli/project-json.ts
+/** Locate top-level values in an already validated JSON document, retaining text. */
+function values(text) {
+	const result = /* @__PURE__ */ new Map();
+	let cursor = 0;
+	const whitespace = () => {
+		while (/\s/u.test(text[cursor] ?? "")) cursor++;
+	};
+	const string = () => {
+		if (text[cursor++] !== "\"") throw new Error("Invalid Oxlint JSON property.");
+		while (cursor < text.length) if (text[cursor] === "\\") cursor += 2;
+		else if (text[cursor++] === "\"") return;
+		throw new Error("Incomplete Oxlint JSON string.");
+	};
+	const value = () => {
+		if (text[cursor] === "\"") return string();
+		if (text[cursor] === "[" || text[cursor] === "{") {
+			let depth = 0;
+			do
+				if (text[cursor] === "\"") string();
+				else {
+					if (text[cursor] === "[" || text[cursor] === "{") depth++;
+					if (text[cursor] === "]" || text[cursor] === "}") depth--;
+					cursor++;
+				}
+			while (depth > 0 && cursor < text.length);
+			if (depth !== 0) throw new Error("Incomplete Oxlint JSON value.");
+			return;
+		}
+		while (cursor < text.length && !/[\s,}]/u.test(text[cursor])) cursor++;
+	};
+	whitespace();
+	if (text[cursor++] !== "{") throw new Error("Oxlint JSON report must be an object.");
+	whitespace();
+	while (text[cursor] !== "}") {
+		const keyStart = cursor;
+		string();
+		const key = JSON.parse(text.slice(keyStart, cursor));
+		if (result.has(key)) throw new Error("Duplicate Oxlint JSON report property.");
+		whitespace();
+		if (text[cursor++] !== ":") throw new Error("Invalid Oxlint JSON property separator.");
+		whitespace();
+		const start = cursor;
+		value();
+		result.set(key, [start, cursor]);
+		whitespace();
+		if (text[cursor] === "}") break;
+		if (text[cursor++] !== ",") throw new Error("Invalid Oxlint JSON report separator.");
+		whitespace();
+	}
+	return result;
+}
+/** Keep the original reporter layout and both diagnostic arrays' authored bytes. */
+function joinProjectJson(source, bridge, totals) {
+	const original = values(source);
+	const template = values(bridge);
+	const diagnostics = (text, fields) => {
+		const span = fields.get("diagnostics");
+		if (!span || text[span[0]] !== "[" || text[span[1] - 1] !== "]") throw new Error("Missing complete Oxlint diagnostics array.");
+		return text.slice(span[0] + 1, span[1] - 1);
+	};
+	const left = diagnostics(source, original), right = diagnostics(bridge, template);
+	const comma = left.trim() && right.trim() ? "," : "";
+	const replacements = {
+		...totals,
+		diagnostics: `[${left}${comma}${right}]`
+	};
+	const patches = Object.entries(replacements).map(([key, replacement]) => {
+		if (typeof replacement === "number" && !Number.isFinite(replacement)) throw new Error(`Invalid Oxlint JSON report total: ${key}`);
+		const span = original.get(key);
+		if (!span) throw new Error(`Missing original Oxlint JSON report property: ${key}`);
+		return {
+			start: span[0],
+			end: span[1],
+			value: String(replacement)
+		};
+	});
+	for (const patch of patches.sort((left, right) => right.start - left.start)) source = source.slice(0, patch.start) + patch.value + source.slice(patch.end);
+	return source;
+}
+//#endregion
+//#region src/cli/project-output.ts
+function unavailableProjectTransport(original, error) {
+	return {
+		...original,
+		status: Math.max(original.status ?? 1, 1),
+		stderr: original.stderr + `\nScript-safe Vue transport unavailable: ${error instanceof Error ? error.message : String(error)}\n`
+	};
+}
+function projectOutputFormat(args) {
+	let format = "default";
+	for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-f" || args[index] === "--format") format = args[++index];
+	else if (args[index].startsWith("--format=")) format = args[index].slice(9);
+	if (![
+		"default",
+		"json",
+		"unix",
+		"stylish"
+	].includes(format)) throw new Error("Original-path project checks support default, JSON, Unix and Stylish reports.");
+	return format;
+}
+function mergeProjectOutput(original, bridge, args) {
+	const format = projectOutputFormat(args);
+	const unavailable = (phase) => ({
+		stdout: original.stdout,
+		stderr: original.stderr + bridge.stderr + (phase === bridge ? bridge.stdout : ""),
+		status: Math.max(original.status ?? 1, bridge.status ?? 1)
+	});
+	let stdout = original.stdout + bridge.stdout;
+	if (format === "json") {
+		for (const phase of [original, bridge]) {
+			if (phase.stdout === "" && phase.status !== 0) return unavailable(phase);
+			if (phase.stdout === "") throw new Error("Original-path project checks received an empty successful JSON report.");
+		}
+		const reports = [];
+		for (const phase of [original, bridge]) try {
+			reports.push(JSON.parse(phase.stdout));
+		} catch (error) {
+			if (phase.status !== 0) return unavailable(phase);
+			throw error;
+		}
+		const [source, template] = reports;
+		if (!Array.isArray(source.diagnostics) || !Array.isArray(template.diagnostics) || typeof source.number_of_rules !== "number" || typeof template.number_of_rules !== "number" || typeof source.number_of_files !== "number" || typeof source.threads_count !== "number" || typeof template.threads_count !== "number" || typeof source.start_time !== "number" || typeof template.start_time !== "number") throw new Error("Original-path project checks require complete Oxlint JSON reports.");
+		const totals = {};
+		for (const key of new Set([...Object.keys(source), ...Object.keys(template)])) {
+			if (!/^number_of_|_count$/u.test(key) || [
+				"number_of_files",
+				"number_of_rules",
+				"threads_count"
+			].includes(key)) continue;
+			if (typeof source[key] !== "number" || typeof template[key] !== "number") throw new Error(`Original-path project checks cannot combine the Oxlint report total: ${key}`);
+			totals[key] = source[key] + template[key];
+		}
+		stdout = joinProjectJson(original.stdout, bridge.stdout, {
+			...totals,
+			number_of_rules: source.number_of_rules + template.number_of_rules,
+			threads_count: Math.max(source.threads_count, template.threads_count),
+			start_time: source.start_time + template.start_time
+		});
+	}
+	return {
+		stdout,
+		stderr: original.stderr + bridge.stderr,
+		status: Math.max(original.status ?? 1, bridge.status ?? 1)
+	};
+}
+//#endregion
 //#region src/cli/scoped-selection.ts
 async function prepareScopedSelection(cwd, originalArgs, vueFiles, run, candidates) {
 	if (vueFiles.length === 0) return void 0;
-	const config = readScopedConfig(cwd, originalArgs);
-	if (config == null) return void 0;
+	if (vueFiles.every(isStandaloneHtmlFile)) return void 0;
+	let config = readScopedConfig(cwd, originalArgs);
+	if (config == null) {
+		const inspection = originalArgs.some((arg) => [
+			"-h",
+			"--help",
+			"-V",
+			"--version",
+			"--print-config",
+			"--rules",
+			"--debug"
+		].includes(arg) || arg.startsWith("--debug="));
+		if (originalArgs.some((arg) => [
+			"--fix",
+			"--fix-suggestions",
+			"--fix-dangerously",
+			"--init",
+			"--suppress-all",
+			"--prune-suppressions",
+			"--lsp"
+		].includes(arg))) throw new Error("Script-safe Vue transport cannot preserve writes or LSP execution.");
+		if (inspection) return { result: await run(originalArgs) };
+		const selection = await run([
+			"--debug",
+			"files",
+			...originalArgs
+		]);
+		if (selection.status !== 0) return { result: selection };
+		const selected = parseFiles(cwd, selection);
+		const original = await run(originalArgs);
+		if (vueFiles.some(isStandaloneHtmlFile)) return { result: unavailableProjectTransport(original, /* @__PURE__ */ new Error("Scoped Vue transport cannot combine standalone HTML and Vue targets.")) };
+		if (!vueFiles.some((file) => selected.includes(file))) return { result: original };
+		return { result: {
+			...original,
+			status: Math.max(original.status ?? 1, 1),
+			stderr: original.stderr + "Script-safe Vue transport requires one regular JSON or TS/MTS object config; the original engine report is retained, but Vize transport is unqualified.\n"
+		} };
+	}
 	const options = withoutLintTargets(originalArgs);
 	if (options.some((arg) => [
 		"--debug",
@@ -494,17 +927,43 @@ async function prepareScopedSelection(cwd, originalArgs, vueFiles, run, candidat
 		...originalArgs
 	]);
 	if (selection.status !== 0) return { result: selection };
-	validateScopedConfig(config, originalArgs);
+	config = await loadScopedConfig(config);
 	const selected = parseFiles(cwd, selection);
+	validateNestedConfigs(config, selected);
 	if (selected.some((file) => !candidates.has(file))) throw new Error("Scoped Vue transport cannot bind every selected file to an original candidate.");
 	const selectedVue = vueFiles.filter((file) => selected.includes(file));
-	if (selectedVue.length === 0) return { result: await run(originalArgs) };
-	const mirror = createScopedMirror(cwd, config, selectedVue);
+	if (selectedVue.length === 0) {
+		const original = await run(originalArgs);
+		return { result: vueFiles.some(isStandaloneHtmlFile) ? unavailableProjectTransport(original, /* @__PURE__ */ new Error("Scoped Vue transport cannot combine standalone HTML and Vue targets.")) : original };
+	}
+	const bridgeOptions = bridgeProjectArgs(options);
+	projectOutputFormat(options);
+	const phases = splitProjectConfig(config);
+	validateScopedConfig(phases.bridge, bridgeOptions);
+	let originalResult;
+	let mirror;
 	try {
-		const args = [...options];
+		const source = writeOriginalProjectConfig(phases.original);
+		try {
+			const sourceArgs = replaceConfigArgs(originalArgs, source.file);
+			const sourceSelection = await run([
+				"--debug",
+				"files",
+				...sourceArgs
+			]);
+			if (sourceSelection.status !== 0 || !equalFiles(selected, parseFiles(cwd, sourceSelection))) throw new Error("Original-path project checks changed Oxlint's selected files.");
+			originalResult = await run(sourceArgs);
+		} finally {
+			source.cleanup();
+		}
+		config = phases.bridge;
+		if (vueFiles.some(isStandaloneHtmlFile)) throw new Error("Scoped Vue transport cannot combine standalone HTML and Vue targets.");
+		mirror = createScopedMirror(cwd, config, selectedVue);
+		const args = [...bridgeOptions];
+		if (config.discovered) args.unshift("--config", mirror.sibling);
 		for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-c" || args[index] === "--config") args[++index] = mirror.sibling;
 		else if (args[index].startsWith("--config=")) args[index] = `--config=${mirror.sibling}`;
-		const projected = selected.map((file) => mirror.originalsToCopies.get(file) ?? file).sort();
+		const projected = selectedVue.map((file) => mirror.originalsToCopies.get(file) ?? file).sort();
 		args.push(...projected);
 		const transported = await run([
 			"--debug",
@@ -514,16 +973,24 @@ async function prepareScopedSelection(cwd, originalArgs, vueFiles, run, candidat
 		if (transported.status !== 0 || transported.stderr !== "" || !equalFiles(projected, parseFiles(cwd, transported))) throw new Error("Scoped Vue transport changed Oxlint's selected files. The current ignore/config envelope cannot preserve original path ownership.\n" + transported.stdout + transported.stderr);
 		return {
 			args,
+			originalResult,
 			prepared: {
 				appendedArgs: [],
 				pathReplacements: mirror.pathReplacements,
+				locations: mirror.locations,
 				usedScriptlessWorkaround: true,
 				cleanup: mirror.cleanup
 			}
 		};
 	} catch (error) {
-		mirror.cleanup();
-		throw error;
+		let failure = error;
+		try {
+			mirror?.cleanup();
+		} catch (cleanupError) {
+			failure = new AggregateError([error, cleanupError], "Vue transport and cleanup failed.");
+		}
+		if (originalResult) return { result: unavailableProjectTransport(originalResult, failure) };
+		throw failure;
 	}
 }
 function parseFiles(cwd, result) {
@@ -554,26 +1021,44 @@ async function main() {
 	const prepared = sourceResult ? prepareScriptlessWorkaroundFiles(cwd, []) : transport?.prepared ?? prepareScriptlessWorkaroundFiles(cwd, lintFiles);
 	const args = [oxlintEntrypoint, ...transport?.args ?? [...forwardedArgs, ...prepared.appendedArgs]];
 	try {
-		const result = sourceResult ?? await runOxlint(process.execPath, args, cwd);
-		const stdout = rewriteReportedPaths(result.stdout, prepared.pathReplacements);
-		const stderr = rewriteReportedPaths(result.stderr, prepared.pathReplacements);
+		let result;
+		let merged;
+		try {
+			result = sourceResult ?? await runOxlint(process.execPath, args, cwd);
+			const mappedStdout = rewriteReportedPaths(rewriteReportedLocations(result.stdout, prepared.locations), prepared.pathReplacements);
+			const mappedStderr = rewriteReportedPaths(rewriteReportedLocations(result.stderr, prepared.locations), prepared.pathReplacements);
+			merged = {
+				...result,
+				stdout: mappedStdout,
+				stderr: mappedStderr
+			};
+			if (transport?.originalResult) merged = mergeProjectOutput(transport.originalResult, merged, forwardedArgs);
+		} catch (error) {
+			if (transport?.originalResult) {
+				process.exitCode = Math.max(transport.originalResult.status ?? 1, result?.status ?? 1, 1);
+				await writeStream(process.stdout, transport.originalResult.stdout);
+				await writeStream(process.stderr, transport.originalResult.stderr + (result?.stderr ?? "") + (result?.stdout ?? ""));
+			}
+			throw error;
+		}
+		const { stdout, stderr } = merged;
 		if (stdout) await writeStream(process.stdout, stdout);
 		if (stderr) await writeStream(process.stderr, stderr);
-		if (result.status === 0 && stdout === "" && stderr === "" && expectsLintReport(forwardedArgs)) {
+		if (merged.status === 0 && stdout === "" && stderr === "" && expectsLintReport(forwardedArgs)) {
 			await writeStream(process.stderr, `The oxlint run at ${oxlintEntrypoint} exited 0 but produced no report, although the requested format always emits one. Refusing to treat the silent run as a clean lint result.
 `);
 			process.exitCode = 1;
 			return;
 		}
 		if (prepared.usedScriptlessWorkaround && (forwardedArgs.includes("--fix") || forwardedArgs.includes("--fix-suggestions"))) await writeStream(process.stderr, "\n[oxlint-plugin-vize] Temporary Vue workaround is active; fixes are not applied back to original files yet.\n");
-		process.exitCode = result.status ?? 1;
+		process.exitCode = merged.status ?? 1;
 	} finally {
 		prepared.cleanup();
 	}
 }
 main().catch((error) => {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
-	process.exitCode = 1;
+	process.exitCode = Math.max(Number(process.exitCode) || 1, 1);
 });
 function runOxlint(executable, args, cwd) {
 	return new Promise((resolve, reject) => {