oxlint-plugin-vize 0.57.0 → 0.59.0

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,249 @@
+import { n as hasScriptLikeBlock, t as appendScriptlessWorkaround } from "./workaround-57-10EZz.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/cli/args.ts
+const OPTION_NAMES_WITH_VALUES = new Set([
+	"-A",
+	"-D",
+	"-W",
+	"-c",
+	"-f",
+	"--config",
+	"--cwd",
+	"--deny",
+	"--fix-suggestions",
+	"--format",
+	"--ignore-path",
+	"--ignore-pattern",
+	"--import-plugin",
+	"--jsx-a11y-plugin",
+	"--max-warnings",
+	"--nextjs-plugin",
+	"--node-plugin",
+	"--promise-plugin",
+	"--react-perf-plugin",
+	"--react-plugin",
+	"--threads",
+	"--tsconfig",
+	"--typescript-plugin",
+	"--unicorn-plugin",
+	"--vitest-plugin",
+	"--warn"
+]);
+function getLintTargets(argv) {
+	const targets = [];
+	let collectEverything = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (collectEverything) {
+			targets.push(arg);
+			continue;
+		}
+		if (arg === "--") {
+			collectEverything = true;
+			continue;
+		}
+		if (arg.startsWith("--") && arg.includes("=")) continue;
+		if (OPTION_NAMES_WITH_VALUES.has(arg)) {
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("-")) continue;
+		targets.push(arg);
+	}
+	return targets.length === 0 ? ["."] : targets;
+}
+//#endregion
+//#region src/cli/files.ts
+const GLOB_PATTERN = /[*?[\]{}]/u;
+function collectVueFilesFromTargets(cwd, targets) {
+	const files = /* @__PURE__ */ new Set();
+	for (const target of targets) for (const file of collectVueFilesFromTarget(cwd, target)) files.add(file);
+	return [...files];
+}
+function collectVueFilesFromTarget(cwd, target) {
+	if (GLOB_PATTERN.test(target)) return fs.globSync(target, {
+		cwd,
+		withFileTypes: false,
+		exclude: ["**/node_modules/**", "**/.git/**"]
+	}).map((entry) => path.resolve(cwd, entry)).filter(isVueFile);
+	const absoluteTarget = path.resolve(cwd, target);
+	if (!fs.existsSync(absoluteTarget)) return [];
+	if (fs.statSync(absoluteTarget).isDirectory()) return fs.globSync("**/*.vue", {
+		cwd: absoluteTarget,
+		withFileTypes: false,
+		exclude: ["**/node_modules/**", "**/.git/**"]
+	}).map((entry) => path.resolve(absoluteTarget, entry));
+	return isVueFile(absoluteTarget) ? [absoluteTarget] : [];
+}
+function isVueFile(filename) {
+	return filename.endsWith(".vue");
+}
+//#endregion
+//#region src/cli/oxlint.ts
+const OXLINT_ENTRYPOINT_SEGMENTS = [
+	"node_modules",
+	"oxlint",
+	"bin",
+	"oxlint"
+];
+const PNPM_OXLINT_ENTRYPOINT_PATTERN = "node_modules/.pnpm/oxlint@*/node_modules/oxlint/bin/oxlint";
+function resolveOxlintCliEntrypoint(cwd) {
+	let currentDir = cwd;
+	for (;;) {
+		const candidate = path.join(currentDir, ...OXLINT_ENTRYPOINT_SEGMENTS);
+		if (fs.existsSync(candidate)) return candidate;
+		const pnpmCandidate = fs.globSync(PNPM_OXLINT_ENTRYPOINT_PATTERN, {
+			cwd: currentDir,
+			withFileTypes: false
+		})[0];
+		if (pnpmCandidate != null) return path.resolve(currentDir, pnpmCandidate);
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) throw new Error("Unable to locate oxlint. Install `oxlint` in the current workspace before using `oxlint-vize`.");
+		currentDir = parentDir;
+	}
+}
+//#endregion
+//#region src/cli/output.ts
+function rewriteReportedPaths(output, replacements) {
+	let rewritten = output;
+	const orderedReplacements = [...replacements].sort((left, right) => right[0].length - left[0].length);
+	for (const [from, to] of orderedReplacements) rewritten = rewritten.split(from).join(to);
+	return rewritten;
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("rewriteReportedPaths", () => {
+		it("rewrites both absolute and relative temporary filenames", () => {
+			const replacements = new Map([["/repo/__oxlint_plugin_vize_temp__/100/0-Example.vue", "/repo/src/Example.vue"], ["__oxlint_plugin_vize_temp__/100/0-Example.vue", "/repo/src/Example.vue"]]);
+			expect(rewriteReportedPaths(["__oxlint_plugin_vize_temp__/100/0-Example.vue", "/repo/__oxlint_plugin_vize_temp__/100/0-Example.vue"].join("\n"), replacements)).toBe(["/repo/src/Example.vue", "/repo/src/Example.vue"].join("\n"));
+		});
+	});
+}
+//#endregion
+//#region src/cli/workaround-files.ts
+function prepareScriptlessWorkaroundFiles(cwd, filenames) {
+	const tempDir = path.join(cwd, "__oxlint_plugin_vize_temp__", String(process.pid));
+	const ignoreArgs = [];
+	const tempArgs = [];
+	const pathReplacements = /* @__PURE__ */ new Map();
+	let counter = 0;
+	for (const filename of filenames) {
+		const source = fs.readFileSync(filename, "utf8");
+		if (hasScriptLikeBlock(source)) continue;
+		const relativeFilename = path.relative(cwd, filename);
+		const tempFilename = path.join(tempDir, `${counter}-${path.basename(filename)}`);
+		counter += 1;
+		fs.mkdirSync(path.dirname(tempFilename), { recursive: true });
+		fs.writeFileSync(tempFilename, appendScriptlessWorkaround(source, filename));
+		ignoreArgs.push("--ignore-pattern", toCliPath(relativeFilename));
+		tempArgs.push(tempFilename);
+		registerPathReplacementVariants(pathReplacements, cwd, tempFilename, filename);
+	}
+	return {
+		appendedArgs: [...ignoreArgs, ...tempArgs],
+		cleanup() {
+			if (pathReplacements.size === 0) return;
+			fs.rmSync(tempDir, {
+				force: true,
+				recursive: true
+			});
+		},
+		pathReplacements,
+		usedScriptlessWorkaround: pathReplacements.size > 0
+	};
+}
+function toCliPath(filename) {
+	return filename.split(path.sep).join("/");
+}
+function registerPathReplacementVariants(replacements, cwd, tempFilename, originalFilename) {
+	const relativeTempFilename = path.relative(cwd, tempFilename);
+	const relativeOriginalFilename = getReportedOriginalFilename(cwd, originalFilename);
+	const variants = new Set([
+		[tempFilename, relativeOriginalFilename],
+		[toCliPath(tempFilename), toCliPath(relativeOriginalFilename)],
+		[relativeTempFilename, relativeOriginalFilename],
+		[toCliPath(relativeTempFilename), toCliPath(relativeOriginalFilename)]
+	]);
+	for (const [from, to] of variants) {
+		if (!from || !to) continue;
+		replacements.set(from, to);
+	}
+}
+function getReportedOriginalFilename(cwd, filename) {
+	const relativeFilename = path.relative(cwd, filename);
+	if (relativeFilename && !relativeFilename.startsWith(`..${path.sep}`) && relativeFilename !== ".." && !path.isAbsolute(relativeFilename)) return relativeFilename;
+	return filename;
+}
+//#endregion
+//#region src/cli.ts
+async function main() {
+	const cwd = process.cwd();
+	const forwardedArgs = process.argv.slice(2);
+	const prepared = prepareScriptlessWorkaroundFiles(cwd, collectVueFilesFromTargets(cwd, getLintTargets(forwardedArgs)));
+	const args = [
+		resolveOxlintCliEntrypoint(cwd),
+		...forwardedArgs,
+		...prepared.appendedArgs
+	];
+	try {
+		const result = await runOxlint(process.execPath, args, cwd);
+		const stdout = rewriteReportedPaths(result.stdout, prepared.pathReplacements);
+		const stderr = rewriteReportedPaths(result.stderr, prepared.pathReplacements);
+		if (stdout) await writeStream(process.stdout, stdout);
+		if (stderr) await writeStream(process.stderr, stderr);
+		if (prepared.usedScriptlessWorkaround && forwardedArgs.includes("--fix")) await writeStream(process.stderr, "\n[oxlint-plugin-vize] Scriptless SFC workaround is active; fixes are not applied back to original .vue files yet.\n");
+		process.exitCode = result.status ?? 1;
+	} finally {
+		prepared.cleanup();
+	}
+}
+main().catch((error) => {
+	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+	process.exitCode = 1;
+});
+function runOxlint(executable, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(executable, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		child.stdout.on("data", (chunk) => {
+			stdoutChunks.push(asBuffer(chunk));
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrChunks.push(asBuffer(chunk));
+		});
+		child.on("error", reject);
+		child.on("close", (status) => {
+			resolve({
+				status,
+				stderr: Buffer.concat(stderrChunks).toString("utf8"),
+				stdout: Buffer.concat(stdoutChunks).toString("utf8")
+			});
+		});
+	});
+}
+function asBuffer(chunk) {
+	return typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+}
+function writeStream(stream, text) {
+	return new Promise((resolve, reject) => {
+		stream.write(text, (error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/plugin.d.ts
+declare const _default: _$_oxlint_plugins0.Plugin;
+//#endregion
+//#region src/model.d.ts
+type PatinaPreset = "general-recommended" | "essential" | "incremental" | "opinionated" | "nuxt";
+//#endregion
+//#region src/configs.d.ts
+type OxlintRuleSeverity = "error" | "warn";
+type OxlintRuleConfig = Record<string, OxlintRuleSeverity>;
+type VizeRuleConfigPreset = Exclude<PatinaPreset, "incremental"> | "all";
+interface VizeRuleConfigOptions {
+  includeTypeAware?: boolean;
+  preset?: VizeRuleConfigPreset;
+}
+declare function createVizeRuleConfig(options?: VizeRuleConfigOptions): OxlintRuleConfig;
+declare const configs: {
+  readonly all: OxlintRuleConfig;
+  readonly essential: OxlintRuleConfig;
+  readonly nuxt: OxlintRuleConfig;
+  readonly opinionated: OxlintRuleConfig;
+  readonly opinionatedWithTypeAware: OxlintRuleConfig;
+  readonly recommended: OxlintRuleConfig;
+  readonly recommendedWithTypeAware: OxlintRuleConfig;
+};
+//#endregion
+export { type OxlintRuleConfig, type OxlintRuleSeverity, type VizeRuleConfigOptions, configs, createVizeRuleConfig, _default as default };

package/dist/index.mjs

@@ -0,0 +1,484 @@
+import { a as extractSfcBlocks, i as compareLineColumn, o as formatBlockLabel, r as resolveWorkaroundSource, s as getDiagnosticBlock } from "./workaround-57-10EZz.mjs";
+import { createRequire } from "node:module";
+import { definePlugin, defineRule } from "@oxlint/plugins";
+import fs, { readFileSync } from "node:fs";
+import path from "node:path";
+//#region src/native.ts
+const require = createRequire(import.meta.url);
+const FALLBACK_BINDING_PACKAGE = "@vizejs/native";
+let bindingCache = null;
+function isMusl() {
+	const report = process.report?.getReport();
+	if (typeof report === "object" && report !== null && "header" in report) return !report.header.glibcVersionRuntime;
+	try {
+		return readFileSync(require("node:child_process").execSync("which ldd").toString().trim(), "utf8").includes("musl");
+	} catch {
+		return true;
+	}
+}
+function getBindingPackageName() {
+	const { arch, platform } = process;
+	switch (platform) {
+		case "darwin": switch (arch) {
+			case "arm64": return "@vizejs/native-darwin-arm64";
+			case "x64": return "@vizejs/native-darwin-x64";
+			default: throw new Error(`Unsupported architecture on macOS: ${arch}`);
+		}
+		case "linux": switch (arch) {
+			case "arm64": return isMusl() ? "@vizejs/native-linux-arm64-musl" : "@vizejs/native-linux-arm64-gnu";
+			case "x64": return isMusl() ? "@vizejs/native-linux-x64-musl" : "@vizejs/native-linux-x64-gnu";
+			default: throw new Error(`Unsupported architecture on Linux: ${arch}`);
+		}
+		case "win32": switch (arch) {
+			case "arm64": return "@vizejs/native-win32-arm64-msvc";
+			case "x64": return "@vizejs/native-win32-x64-msvc";
+			default: throw new Error(`Unsupported architecture on Windows: ${arch}`);
+		}
+		default: throw new Error(`Unsupported OS: ${platform}`);
+	}
+}
+function isPatinaBinding(binding) {
+	return typeof binding.lintPatinaSfc === "function" && typeof binding.getPatinaRules === "function";
+}
+function loadBinding() {
+	if (bindingCache) return bindingCache;
+	const attemptedPackages = getAttemptedPackages();
+	let lastError = null;
+	for (const packageName of attemptedPackages) try {
+		const binding = require(packageName);
+		if (!isPatinaBinding(binding)) throw new Error(`${packageName} does not expose the Patina Oxlint bridge.`);
+		bindingCache = binding;
+		return bindingCache;
+	} catch (error) {
+		lastError = error;
+	}
+	const message = lastError instanceof Error && lastError.message ? ` ${lastError.message}` : "";
+	throw new Error(`Failed to load the Vize native binding. Tried ${attemptedPackages.join(", ")}.${message}`);
+}
+function getAttemptedPackages() {
+	const platformBindingPackage = getBindingPackageName();
+	return shouldPreferWorkspaceBinding(resolveFallbackBindingPath()) ? [FALLBACK_BINDING_PACKAGE, platformBindingPackage] : [platformBindingPackage, FALLBACK_BINDING_PACKAGE];
+}
+function resolveFallbackBindingPath() {
+	try {
+		return require.resolve(FALLBACK_BINDING_PACKAGE);
+	} catch {
+		return null;
+	}
+}
+function shouldPreferWorkspaceBinding(resolvedPath) {
+	const override = process.env.VIZE_PREFER_WORKSPACE_BINDING;
+	if (override === "1" || override === "true") return true;
+	if (override === "0" || override === "false") return false;
+	if (resolvedPath == null) return false;
+	return resolvedPath.includes(`${path.sep}npm${path.sep}vize-native${path.sep}`);
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("shouldPreferWorkspaceBinding", () => {
+		it("detects the local workspace native package", () => {
+			expect(shouldPreferWorkspaceBinding(`${path.sep}Users${path.sep}example${path.sep}repo${path.sep}npm${path.sep}vize-native${path.sep}index.js`)).toBe(true);
+		});
+		it("ignores published platform packages", () => {
+			expect(shouldPreferWorkspaceBinding(`${path.sep}repo${path.sep}node_modules${path.sep}.pnpm${path.sep}@vizejs+native-darwin-arm64${path.sep}node_modules${path.sep}@vizejs${path.sep}native-darwin-arm64${path.sep}index.js`)).toBe(false);
+		});
+		it("returns false when the fallback package cannot be resolved", () => {
+			expect(shouldPreferWorkspaceBinding(null)).toBe(false);
+		});
+	});
+}
+//#endregion
+//#region src/binding.ts
+function lintPatina(source, filename, settings, enabledRules) {
+	return loadBinding().lintPatinaSfc(source, {
+		filename,
+		locale: settings.locale,
+		helpLevel: settings.helpLevel,
+		preset: settings.preset,
+		enabledRules: enabledRules ? [...enabledRules] : void 0
+	});
+}
+function getPatinaRules() {
+	return loadBinding().getPatinaRules();
+}
+//#endregion
+//#region src/script-map.ts
+function createSingleScriptMap(source, extractedScript) {
+	if (!extractedScript) return null;
+	const blocks = extractSfcBlocks(source).filter((block) => block.kind === "script" || block.kind === "script-setup");
+	if (blocks.length !== 1) return null;
+	const [block] = blocks;
+	return block.content === extractedScript ? { block } : null;
+}
+function mapToScriptLoc(diagnostic, scriptMap) {
+	if (!scriptMap) return null;
+	const { block } = scriptMap;
+	if (compareLineColumn(diagnostic.location.start, block.contentStart) < 0 || compareLineColumn(diagnostic.location.end, block.contentEnd) > 0) return null;
+	return {
+		start: toScriptPosition(diagnostic.location.start, block.contentStart),
+		end: toScriptPosition(diagnostic.location.end, block.contentStart)
+	};
+}
+function toScriptPosition(position, contentStart) {
+	if (position.line === contentStart.line) return {
+		line: 1,
+		column: position.column - contentStart.column + 1
+	};
+	return {
+		line: position.line - contentStart.line + 1,
+		column: position.column
+	};
+}
+//#endregion
+//#region src/settings.ts
+const HELP_LEVELS = new Set([
+	"none",
+	"short",
+	"full"
+]);
+const PRESET_ALIASES = new Map([
+	["generalrecommended", "general-recommended"],
+	["happypath", "general-recommended"],
+	["happy", "general-recommended"],
+	["default", "general-recommended"],
+	["recommended", "general-recommended"],
+	["essential", "essential"],
+	["incremental", "incremental"],
+	["opinionated", "opinionated"],
+	["opnionated", "opinionated"],
+	["strict", "opinionated"],
+	["all", "opinionated"],
+	["nuxt", "nuxt"]
+]);
+function isVueLikeFile(filename) {
+	return filename.endsWith(".vue");
+}
+function getVizeSettings(context) {
+	const settings = context.settings;
+	return parseVizeSettings(settings.vize ?? settings.patina);
+}
+function parseVizeSettings(vize) {
+	if (typeof vize !== "object" || vize === null || Array.isArray(vize)) return {};
+	const vizeRecord = vize;
+	const locale = vizeRecord.locale;
+	const helpLevel = vizeRecord.helpLevel;
+	const preset = vizeRecord.preset;
+	const showHelp = vizeRecord.showHelp;
+	const resolved = {};
+	if (typeof locale === "string") resolved.locale = locale;
+	if (typeof preset === "string") {
+		const normalizedPreset = normalizePreset(preset);
+		if (normalizedPreset) resolved.preset = normalizedPreset;
+	}
+	if (typeof helpLevel === "string" && HELP_LEVELS.has(helpLevel)) {
+		resolved.helpLevel = helpLevel;
+		return resolved;
+	}
+	if (typeof showHelp === "boolean") resolved.helpLevel = showHelp ? "full" : "none";
+	return resolved;
+}
+function getActivePreset(settings) {
+	return settings.preset ?? "general-recommended";
+}
+function isIncrementalPreset(settings) {
+	return getActivePreset(settings) === "incremental";
+}
+function getCacheKey(filename, settings) {
+	return `${filename}::${settings.locale ?? ""}::${settings.helpLevel ?? ""}::${getActivePreset(settings)}`;
+}
+function normalizePreset(value) {
+	return PRESET_ALIASES.get(value.replaceAll(/[-_\s]/gu, "").toLowerCase());
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("parseVizeSettings", () => {
+		it("reads locale, help level, and preset", () => {
+			expect(parseVizeSettings({
+				locale: "ja",
+				helpLevel: "short",
+				preset: "essential"
+			})).toEqual({
+				locale: "ja",
+				helpLevel: "short",
+				preset: "essential"
+			});
+		});
+		it("normalizes preset aliases", () => {
+			expect(parseVizeSettings({ preset: "recommended" })).toEqual({ preset: "general-recommended" });
+			expect(parseVizeSettings({ preset: "incremental" })).toEqual({ preset: "incremental" });
+			expect(parseVizeSettings({ preset: "strict" })).toEqual({ preset: "opinionated" });
+			expect(parseVizeSettings({ preset: "Opnionated" })).toEqual({ preset: "opinionated" });
+		});
+		it("falls back to showHelp for compatibility", () => {
+			expect(parseVizeSettings({
+				locale: "ja",
+				showHelp: false,
+				preset: "Nuxt"
+			})).toEqual({
+				locale: "ja",
+				helpLevel: "none",
+				preset: "nuxt"
+			});
+		});
+		it("ignores invalid values", () => {
+			expect(parseVizeSettings({
+				locale: 1,
+				showHelp: "no",
+				helpLevel: "verbose",
+				preset: "wide"
+			})).toEqual({});
+		});
+		it("ignores non-object vize settings", () => {
+			expect(parseVizeSettings(null)).toEqual({});
+			expect(parseVizeSettings("ja")).toEqual({});
+		});
+	});
+}
+//#endregion
+//#region src/file-state.ts
+const fileStateCache = /* @__PURE__ */ new Map();
+const EMPTY_DIAGNOSTICS = [];
+function getFileState(context) {
+	const settings = getVizeSettings(context);
+	const resolvedSource = resolveWorkaroundSource(fs.readFileSync(context.physicalFilename, "utf8"), context.physicalFilename);
+	const cacheKey = getCacheKey(resolvedSource.filename, settings);
+	const cached = fileStateCache.get(cacheKey);
+	if (cached) return cached;
+	const state = {
+		filename: resolvedSource.filename,
+		source: resolvedSource.source,
+		extractedScript: context.sourceCode.text,
+		usesOriginalLocations: resolvedSource.usesOriginalLocations,
+		reportedRules: /* @__PURE__ */ new Set(),
+		sfcBlocks: void 0,
+		scriptMap: void 0,
+		allDiagnosticsByRule: null,
+		partialDiagnosticsByRule: /* @__PURE__ */ new Map(),
+		requestedRules: /* @__PURE__ */ new Set()
+	};
+	fileStateCache.set(cacheKey, state);
+	return state;
+}
+function getDiagnosticsForRule(context, state, ruleName) {
+	if (state.allDiagnosticsByRule) return state.allDiagnosticsByRule.get(ruleName) ?? EMPTY_DIAGNOSTICS;
+	const cached = state.partialDiagnosticsByRule.get(ruleName);
+	if (cached) return cached;
+	const settings = getVizeSettings(context);
+	if (isIncrementalPreset(settings)) {
+		const diagnostics = lintPatina(state.source, state.filename, settings, [ruleName]).diagnostics;
+		const ruleDiagnostics = indexDiagnosticsByRule(diagnostics).get(ruleName) ?? EMPTY_DIAGNOSTICS;
+		state.partialDiagnosticsByRule.set(ruleName, ruleDiagnostics);
+		return ruleDiagnostics;
+	}
+	if (state.requestedRules.size === 0) {
+		state.requestedRules.add(ruleName);
+		const diagnostics = lintPatina(state.source, state.filename, settings, [ruleName]).diagnostics;
+		const ruleDiagnostics = indexDiagnosticsByRule(diagnostics).get(ruleName) ?? EMPTY_DIAGNOSTICS;
+		state.partialDiagnosticsByRule.set(ruleName, ruleDiagnostics);
+		return ruleDiagnostics;
+	}
+	state.requestedRules.add(ruleName);
+	const allDiagnostics = lintPatina(state.source, state.filename, settings).diagnostics;
+	state.allDiagnosticsByRule = indexDiagnosticsByRule(allDiagnostics);
+	state.partialDiagnosticsByRule.clear();
+	return state.allDiagnosticsByRule.get(ruleName) ?? EMPTY_DIAGNOSTICS;
+}
+function getScriptMap(state) {
+	if (state.scriptMap !== void 0) return state.scriptMap;
+	state.scriptMap = createSingleScriptMap(state.source, state.extractedScript);
+	return state.scriptMap;
+}
+function getSfcBlocks(state) {
+	if (state.sfcBlocks !== void 0) return state.sfcBlocks;
+	state.sfcBlocks = extractSfcBlocks(state.source);
+	return state.sfcBlocks;
+}
+function markRuleAsReported(state, ruleName) {
+	if (state.reportedRules.has(ruleName)) return false;
+	state.reportedRules.add(ruleName);
+	return true;
+}
+function indexDiagnosticsByRule(diagnostics) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const existing = grouped.get(diagnostic.rule);
+		if (existing) {
+			existing.push(diagnostic);
+			continue;
+		}
+		grouped.set(diagnostic.rule, [diagnostic]);
+	}
+	return grouped;
+}
+//#endregion
+//#region src/format.ts
+const helpTextCache = /* @__PURE__ */ new Map();
+function formatPatinaMessage(diagnostic, options) {
+	const sections = [];
+	const summaryLine = createSummaryLine(diagnostic.message);
+	const details = createDetailsBody(diagnostic.message, summaryLine);
+	const summary = options.hasMappedLocation ? summaryLine : `${summaryLine} (${formatInlineLocation(options.blockLabel, diagnostic)})`;
+	if (details) sections.push(formatSection("Details", details));
+	const helpText = resolveHelpText(diagnostic.help, options.helpLevel);
+	if (helpText) sections.push(formatSection("Help", helpText));
+	if (sections.length === 0) return summary;
+	return `${summary}\n${sections.join("\n")}`;
+}
+function createDetailsBody(message, summary) {
+	if (message === summary) return null;
+	if (message.startsWith(summary)) return message.slice(summary.length).trim() || null;
+	return message;
+}
+function formatSection(title, body) {
+	return `    ${title}:\n${indentBlock(body, "      ")}`;
+}
+function formatInlineLocation(blockLabel, diagnostic) {
+	const { line, column } = diagnostic.location.start;
+	return `at ${blockLabel}:${line}:${column}`;
+}
+function resolveHelpText(help, helpLevel) {
+	if (help == null || helpLevel === "none") return null;
+	const plainText = formatHelpText(help);
+	if (helpLevel === "short") return firstMeaningfulLine(plainText);
+	return plainText;
+}
+function formatHelpText(help) {
+	const cached = helpTextCache.get(help);
+	if (cached) return cached;
+	const plainText = help.replace(/\r\n?/gu, "\n").replace(/^\s*```[^\n]*$/gmu, "").replace(/\*\*(.*?)\*\*/gu, "$1").replace(/__(.*?)__/gu, "$1").replace(/`([^`\n]+)`/gu, "$1").replace(/^\s*[-*]\s+/gmu, "- ").replace(/\n{3,}/gu, "\n\n").trim();
+	helpTextCache.set(help, plainText);
+	return plainText;
+}
+function firstMeaningfulLine(text) {
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed) return trimmed;
+	}
+	return null;
+}
+function indentBlock(text, indent) {
+	return text.split("\n").map((line) => `${indent}${line}`).join("\n");
+}
+function createSummaryLine(message) {
+	const firstSentenceEnd = message.indexOf(". ");
+	if (firstSentenceEnd === -1) return message;
+	return message.slice(0, firstSentenceEnd + 1);
+}
+//#endregion
+//#region src/plugin.ts
+function createOxlintDiagnostic(diagnostic, state, helpLevel) {
+	const scriptMap = getScriptMap(state);
+	const loc = state.usesOriginalLocations ? createOriginalSfcLoc(diagnostic) : mapToScriptLoc(diagnostic, scriptMap);
+	const block = loc === null ? getDiagnosticBlock(diagnostic, getSfcBlocks(state)) : null;
+	return {
+		loc: loc ?? {
+			start: {
+				line: 1,
+				column: 1
+			},
+			end: {
+				line: 1,
+				column: 1
+			}
+		},
+		message: formatPatinaMessage(diagnostic, {
+			hasMappedLocation: loc !== null,
+			blockLabel: formatBlockLabel(block),
+			helpLevel
+		})
+	};
+}
+function createOriginalSfcLoc(diagnostic) {
+	return {
+		start: {
+			line: diagnostic.location.start.line,
+			column: Math.max(0, diagnostic.location.start.column - 1)
+		},
+		end: {
+			line: diagnostic.location.end.line,
+			column: Math.max(0, diagnostic.location.end.column - 1)
+		}
+	};
+}
+function createPatinaRule(ruleMeta) {
+	return defineRule({
+		meta: {
+			type: ruleMeta.defaultSeverity === "error" ? "problem" : "suggestion",
+			docs: { description: ruleMeta.description }
+		},
+		createOnce(context) {
+			return { Program() {
+				if (!isVueLikeFile(context.filename)) return;
+				const settings = getVizeSettings(context);
+				const activePreset = getActivePreset(settings);
+				if (!isIncrementalPreset(settings) && !ruleMeta.presets.includes(activePreset)) return;
+				const helpLevel = settings.helpLevel ?? "full";
+				const state = getFileState(context);
+				const diagnostics = getDiagnosticsForRule(context, state, ruleMeta.name);
+				if (diagnostics.length === 0) return;
+				if (!markRuleAsReported(state, ruleMeta.name)) return;
+				for (const diagnostic of diagnostics) context.report(createOxlintDiagnostic(diagnostic, state, helpLevel));
+			} };
+		}
+	});
+}
+var plugin_default = definePlugin({
+	meta: { name: "vize" },
+	rules: Object.fromEntries(getPatinaRules().map((ruleMeta) => [ruleMeta.name, createPatinaRule(ruleMeta)]))
+});
+//#endregion
+//#region src/configs.ts
+const TYPE_AWARE_RULE_PREFIX = "type/";
+function createVizeRuleConfig(options = {}) {
+	const preset = options.preset ?? "general-recommended";
+	const includeTypeAware = options.includeTypeAware ?? false;
+	const rules = {};
+	for (const ruleMeta of getPatinaRules()) {
+		if (!matchesPreset(ruleMeta, preset)) continue;
+		if (!includeTypeAware && isTypeAwareRule(ruleMeta)) continue;
+		rules[`vize/${ruleMeta.name}`] = toOxlintSeverity(ruleMeta.defaultSeverity);
+	}
+	return rules;
+}
+const configs = {
+	all: createVizeRuleConfig({ preset: "all" }),
+	essential: createVizeRuleConfig({ preset: "essential" }),
+	nuxt: createVizeRuleConfig({ preset: "nuxt" }),
+	opinionated: createVizeRuleConfig({ preset: "opinionated" }),
+	opinionatedWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "opinionated"
+	}),
+	recommended: createVizeRuleConfig({ preset: "general-recommended" }),
+	recommendedWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "general-recommended"
+	})
+};
+function matchesPreset(ruleMeta, preset) {
+	return preset === "all" || ruleMeta.presets.includes(preset);
+}
+function isTypeAwareRule(ruleMeta) {
+	return ruleMeta.name.startsWith(TYPE_AWARE_RULE_PREFIX);
+}
+function toOxlintSeverity(severity) {
+	return severity === "warning" ? "warn" : severity;
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("createVizeRuleConfig", () => {
+		it("normalizes Vize warning severity to Oxlint's warn", () => {
+			expect(configs.recommended["vize/vue/no-multi-spaces"]).toBe("warn");
+		});
+		it("filters rules by preset", () => {
+			expect(configs.essential["vize/vue/require-v-for-key"]).toBe("error");
+			expect(configs.essential["vize/vue/require-scoped-style"]).toBeUndefined();
+		});
+		it("skips unstable type-aware rules by default", () => {
+			expect(configs.opinionated["vize/type/require-typed-props"]).toBeUndefined();
+			expect(configs.opinionatedWithTypeAware["vize/type/require-typed-props"]).toBe("warn");
+		});
+	});
+}
+//#endregion
+export { configs, createVizeRuleConfig, plugin_default as default };

package/dist/workaround-57-10EZz.mjs

@@ -0,0 +1,151 @@
+//#region src/sfc-blocks.ts
+const rootBlockPattern = /<([A-Za-z][\w-]*)\b[^>]*>/gu;
+function extractSfcBlocks(source) {
+	const blocks = [];
+	const lineStarts = createLineStartOffsets(source);
+	let cursor = 0;
+	for (;;) {
+		rootBlockPattern.lastIndex = cursor;
+		const match = rootBlockPattern.exec(source);
+		if (match == null) return blocks;
+		const tagName = match[1];
+		const openTag = match[0];
+		const openTagEnd = match.index + openTag.length;
+		const closeTag = `</${tagName}>`;
+		const closeTagStart = source.indexOf(closeTag, openTagEnd);
+		if (closeTagStart === -1) {
+			cursor = openTagEnd;
+			continue;
+		}
+		blocks.push({
+			kind: resolveBlockKind(tagName, openTag),
+			name: tagName,
+			content: source.slice(openTagEnd, closeTagStart),
+			contentStart: offsetToLineColumn(lineStarts, openTagEnd),
+			contentEnd: offsetToLineColumn(lineStarts, closeTagStart)
+		});
+		cursor = closeTagStart + closeTag.length;
+	}
+}
+function getDiagnosticBlock(diagnostic, blocks) {
+	for (const block of blocks) if (compareLineColumn(diagnostic.location.start, block.contentStart) >= 0 && compareLineColumn(diagnostic.location.end, block.contentEnd) <= 0) return block;
+	return null;
+}
+function formatBlockLabel(block) {
+	if (block == null) return "SFC";
+	switch (block.kind) {
+		case "template": return "<template>";
+		case "script": return "<script>";
+		case "script-setup": return "<script setup>";
+		case "style": return "<style>";
+		case "custom": return `<${block.name}>`;
+	}
+}
+function compareLineColumn(left, right) {
+	if (left.line !== right.line) return left.line - right.line;
+	return left.column - right.column;
+}
+function createLineStartOffsets(source) {
+	const lineStarts = [0];
+	for (let index = 0; index < source.length; index += 1) if (source.charCodeAt(index) === 10) lineStarts.push(index + 1);
+	return lineStarts;
+}
+function offsetToLineColumn(lineStarts, offset) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		if (lineStarts[middle] <= offset) {
+			low = middle + 1;
+			continue;
+		}
+		high = middle - 1;
+	}
+	const lineIndex = Math.max(0, low - 1);
+	return {
+		line: lineIndex + 1,
+		column: offset - lineStarts[lineIndex] + 1
+	};
+}
+function resolveBlockKind(tagName, openTag) {
+	if (tagName === "template") return "template";
+	if (tagName === "script") return /\bsetup(?:\s|>|=)/u.test(openTag) ? "script-setup" : "script";
+	if (tagName === "style") return "style";
+	return "custom";
+}
+//#endregion
+//#region src/workaround.ts
+const SCRIPTLESS_WORKAROUND_OPEN_TAG_PREFIX = `<script setup lang="ts" data-oxlint-plugin-vize-scriptless="`;
+const SCRIPTLESS_WORKAROUND_CLOSE_TAG = "<\/script>";
+function hasScriptLikeBlock(source) {
+	return extractSfcBlocks(source).some((block) => block.kind === "script" || block.kind === "script-setup");
+}
+function appendScriptlessWorkaround(source, filename) {
+	return `${createWorkaroundScript(source, filename)}${source}`;
+}
+function resolveWorkaroundSource(source, fallbackFilename) {
+	if (!source.startsWith(SCRIPTLESS_WORKAROUND_OPEN_TAG_PREFIX)) return {
+		filename: fallbackFilename,
+		source,
+		usesOriginalLocations: false
+	};
+	const encodedFilenameStart = SCRIPTLESS_WORKAROUND_OPEN_TAG_PREFIX.length;
+	const encodedFilenameEnd = source.indexOf(`">`, encodedFilenameStart);
+	if (encodedFilenameEnd === -1) return {
+		filename: fallbackFilename,
+		source,
+		usesOriginalLocations: false
+	};
+	const closeTagStart = source.indexOf(SCRIPTLESS_WORKAROUND_CLOSE_TAG, encodedFilenameEnd + 2);
+	if (closeTagStart === -1) return {
+		filename: fallbackFilename,
+		source,
+		usesOriginalLocations: false
+	};
+	let strippedSourceStart = closeTagStart + 9;
+	if (source.charCodeAt(strippedSourceStart) === 13) strippedSourceStart += 1;
+	if (source.charCodeAt(strippedSourceStart) === 10) strippedSourceStart += 1;
+	return {
+		filename: decodeWorkaroundFilename(source.slice(encodedFilenameStart, encodedFilenameEnd)) ?? fallbackFilename,
+		source: source.slice(strippedSourceStart),
+		usesOriginalLocations: true
+	};
+}
+function createWorkaroundScript(source, filename) {
+	return `${SCRIPTLESS_WORKAROUND_OPEN_TAG_PREFIX}${encodeWorkaroundFilename(filename)}">${createWhitespaceMirror(source)}<\/script>\n`;
+}
+function createWhitespaceMirror(source) {
+	return source.replaceAll(/[^\r\n]/gu, " ");
+}
+function encodeWorkaroundFilename(filename) {
+	return Buffer.from(filename, "utf8").toString("base64url");
+}
+function decodeWorkaroundFilename(encoded) {
+	try {
+		return Buffer.from(encoded, "base64url").toString("utf8");
+	} catch {
+		return null;
+	}
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("scriptless workaround helpers", () => {
+		it("detects script blocks", () => {
+			expect(hasScriptLikeBlock("<template><div /></template>")).toBe(false);
+			expect(hasScriptLikeBlock("<template><div /></template>\n<script setup>const x = 1<\/script>")).toBe(true);
+		});
+		it("appends and resolves the workaround payload", () => {
+			const source = "<template>\n  <div>hello</div>\n</template>\n";
+			const filename = "/Users/example/Hello.vue";
+			const appended = appendScriptlessWorkaround(source, filename);
+			expect(appended).toMatch(/oxlint-plugin-vize-scriptless/u);
+			expect(resolveWorkaroundSource(appended, "/Users/example/fallback.vue")).toEqual({
+				filename,
+				source,
+				usesOriginalLocations: true
+			});
+		});
+	});
+}
+//#endregion
+export { extractSfcBlocks as a, compareLineColumn as i, hasScriptLikeBlock as n, formatBlockLabel as o, resolveWorkaroundSource as r, getDiagnosticBlock as s, appendScriptlessWorkaround as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-vize",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "Oxlint JS plugin bridge for Vize Patina",
   "keywords": [
     "lint",
@@ -40,21 +40,21 @@
   "devDependencies": {
     "@tsdown/css": "0.21.9",
     "@types/node": "25.6.0",
-    "@vizejs/native": "0.57.0",
+    "@vizejs/native": "0.59.0",
     "tsdown": "0.21.9",
     "typescript": "6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.19",
     "vite-plus": "0.1.19"
   },
   "optionalDependencies": {
-    "@vizejs/native-darwin-arm64": "0.57.0",
-    "@vizejs/native-darwin-x64": "0.57.0",
-    "@vizejs/native-linux-arm64-gnu": "0.57.0",
-    "@vizejs/native-linux-arm64-musl": "0.57.0",
-    "@vizejs/native-linux-x64-gnu": "0.57.0",
-    "@vizejs/native-linux-x64-musl": "0.57.0",
-    "@vizejs/native-win32-arm64-msvc": "0.57.0",
-    "@vizejs/native-win32-x64-msvc": "0.57.0"
+    "@vizejs/native-darwin-arm64": "0.59.0",
+    "@vizejs/native-darwin-x64": "0.59.0",
+    "@vizejs/native-linux-arm64-gnu": "0.59.0",
+    "@vizejs/native-linux-arm64-musl": "0.59.0",
+    "@vizejs/native-linux-x64-gnu": "0.59.0",
+    "@vizejs/native-linux-x64-musl": "0.59.0",
+    "@vizejs/native-win32-arm64-msvc": "0.59.0",
+    "@vizejs/native-win32-x64-msvc": "0.59.0"
   },
   "engines": {
     "node": ">=24"