oxlint-plugin-vize 0.33.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ubugeeei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# oxlint-plugin-vize
+
+Oxlint JS plugin bridge for Vize Patina.
+
+This package lets Oxlint execute Patina through Vize's native binding while still using Oxlint's JS plugin model and rule configuration.
+
+> [!IMPORTANT]
+> `oxlint-plugin-vize` is a terminal-first Vue SFC linting package.
+> Until upstream Vue support in Oxlint matures, prefer `oxlint-vize -f stylish` for day-to-day output and treat machine-readable / full-fidelity original-SFC reporting as best-effort.
+
+## Main Features
+
+- Runs Vize Patina rules inside Oxlint as `vize/*` diagnostics, so Vue-specific findings can live beside Oxlint core rules in one command.
+- Keeps Oxlint's existing rules and built-in `vue` plugin active. The bridge adds Vize rules; it does not replace `eqeqeq`, `no-console`, or your existing `vue/*` setup.
+- Ships preset rule maps for JS/TS Oxlint configs: `configs.recommended`, `configs.essential`, `configs.opinionated`, `configs.nuxt`, `configs.all`, and type-aware opt-in variants.
+- Supports runtime settings through `settings.vize`, including `locale`, `preset`, and `helpLevel`.
+- Provides the `oxlint-vize` CLI wrapper, which runs Oxlint with a scriptless-SFC workaround and rewrites temporary paths back to the original `.vue` files.
+- Resolves Vize native bindings through platform-specific optional dependencies, so published installs do not need a separate `@vizejs/native` package.
+- Caches file contents and native rule results for the lifetime of the Oxlint process, reducing duplicate work when several Vize rules are enabled for the same file.
+
+## Performance
+
+The bridge is optimized around Oxlint's per-rule execution model:
+
+- The first enabled Patina rule on a file runs native linting for that rule only.
+- If a second Patina rule is encountered on the same file, the bridge upgrades to one shared full-file Patina pass and reuses that result for the remaining Patina rules.
+- File contents and rule results are cached per file and locale for the lifetime of the Oxlint process.
+
+## Installation
+
+`oxlint-plugin-vize` targets Node 24+. In this repository, Vite+ reads `.node-version` for you, so the usual setup is:
+
+```bash
+vp install
+vp run --filter './npm/vize-native' build
+vp run --filter './npm/oxlint-plugin-vize' build
+```
+
+Install it from npm with:
+
+```bash
+pnpm add -D oxlint oxlint-plugin-vize
+```
+
+`oxlint-plugin-vize` pulls the appropriate Vize native binding for the current platform through optional dependencies, so no separate `@vizejs/native` install is required for published builds.
+
+## Usage
+
+Enable Oxlint's built-in `vue` plugin as well as this JS plugin:
+
+```json
+{
+  "plugins": ["vue"],
+  "jsPlugins": ["oxlint-plugin-vize"],
+  "rules": {
+    "eqeqeq": "error",
+    "no-console": "warn",
+    "vize/vue/require-v-for-key": "error",
+    "vize/vue/no-v-html": "warn"
+  }
+}
+```
+
+This bridge only adds the `vize/*` rules. Oxlint's existing core rules and built-in plugin rules still run as configured, so checks like `eqeqeq`, `no-console`, or your existing `vue/*` setup continue to report normally.
+
+If you want a lower-config JS/TS Oxlint setup, the package also exports preset rule maps:
+
+```js
+import { configs } from "oxlint-plugin-vize";
+
+export default {
+  plugins: ["vue"],
+  jsPlugins: ["oxlint-plugin-vize"],
+  settings: {
+    vize: {
+      helpLevel: "short",
+      preset: "opinionated",
+    },
+  },
+  rules: configs.opinionated,
+};
+```
+
+`configs.recommended`, `configs.essential`, `configs.opinionated`, `configs.nuxt`, and `configs.all` intentionally skip Vize's unstable type-aware rules for now. If you explicitly want those experimental rules too, use `configs.recommendedWithTypeAware`, `configs.opinionatedWithTypeAware`, or `createVizeRuleConfig({ includeTypeAware: true, preset: ... })`.
+
+You can pass Patina settings through `settings.vize`:
+
+```json
+{
+  "settings": {
+    "vize": {
+      "locale": "ja",
+      "preset": "essential",
+      "helpLevel": "short"
+    }
+  }
+}
+```
+
+- `preset` accepts `"general-recommended"`, `"essential"`, `"incremental"`, `"opinionated"`, or `"nuxt"`.
+- `preset` defaults to `"general-recommended"`.
+- Bundle presets keep out-of-bundle rules quiet even if they are still listed in `rules`.
+- `"incremental"` skips bundle gating and runs only the Vize rules you explicitly configure in Oxlint.
+- `"opinionated"` is the preset that enables Vize's built-in script rules such as `vize/script/no-options-api`.
+- Legacy aliases such as `"GeneralRecommended"`, `"Essential"`, `"Incremental"`, `"Opinionated"`, `"Nuxt"`, and `"happy-path"` are still accepted for compatibility.
+- `helpLevel` accepts `"full"`, `"short"`, or `"none"`.
+- `helpLevel: "full"` only expands the Patina remediation text. It does not restore original-SFC formatter anchors or machine-readable range fidelity.
+- `showHelp` is still accepted for backward compatibility, but `helpLevel` is the preferred setting.
+
+For example, this keeps Oxlint focused on correctness-only Vize diagnostics while still allowing your existing Oxlint rules to run unchanged:
+
+```json
+{
+  "settings": {
+    "vize": {
+      "preset": "essential",
+      "helpLevel": "short"
+    }
+  },
+  "rules": {
+    "vize/vue/require-v-for-key": "error",
+    "vize/vue/require-scoped-style": "error"
+  }
+}
+```
+
+In that config, `vize/vue/require-v-for-key` can report, while `vize/vue/require-scoped-style` stays silent because it belongs to the broader `"general-recommended"` preset.
+
+If you want to adopt Vize one rule at a time, use `"preset": "incremental"`. In that mode, preset membership no longer suppresses configured rules, so only the Vize rules you list under `rules` will run.
+
+For day-to-day terminal runs, the recommended command today is:
+
+```bash
+pnpm exec oxlint-vize -c .oxlintrc.json -f stylish src
+```
+
+`oxlint-vize` is a thin wrapper around `oxlint`. Until upstream JS plugin coverage improves, it appends a temporary `<script setup>` block only for scriptless `.vue` files so Oxlint's JS plugin pipeline still invokes Vize, then rewrites reported paths back to the original files.
+`stylish` is currently the most usable compromise for mixed Oxlint + Vize output because the Patina summary can inline the original SFC location even though Oxlint still anchors JS plugin diagnostics to the extracted script program.
+
+## Limitations
+
+- Raw `oxlint` still misses files without `<script>` or `<script setup>`. The temporary `oxlint-vize` wrapper works around this by generating a transient script block for scriptless `.vue` files before invoking `oxlint`.
+- Oxlint JS plugins only accept ranges inside the extracted Vue script program. For template diagnostics, Vize now inlines the original SFC block and `line:column` into the summary, while the formatter anchor still points at the script block.
+- Formatter parity is not there yet. `stylish` is recommended for human-readable terminal output, while `json` and other machine-readable outputs are best treated as debugging aids for original template/style positions.
+- Oxlint core rules that need JavaScript bindings extracted from Vue templates, such as template-aware unused-variable checks, still depend on upstream work in [Oxc's Better Vue Support](https://github.com/oxc-project/oxc/issues/15761).
+- Vize's own SFC diagnostics can run through the plugin, but precise original-SFC ranges across all Oxlint formatters depend on the JS plugin reporting work tracked in [oxc-project/oxc#20465](https://github.com/oxc-project/oxc/issues/20465).
+- Type-aware Vize rules are experimental and excluded from the default exported configs. Opt into them explicitly with `configs.recommendedWithTypeAware`, `configs.opinionatedWithTypeAware`, or `createVizeRuleConfig({ includeTypeAware: true, preset: ... })`.
+
+## Current expectations
+
+- This release is meant for terminal-first workflows.
+- It is not yet a promise of precise original-SFC spans across every Oxlint formatter.
+- Once Oxlint can preserve original Vue positions for JS plugins reliably, Vize can improve formatter parity and machine-readable reporting without relying on summary fallbacks.

package/bin/oxlint-vize

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.mjs";

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

@@ -0,0 +1,66 @@
+{
+  "name": "oxlint-plugin-vize",
+  "version": "0.33.0",
+  "description": "Oxlint JS plugin bridge for Vize Patina",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "oxlint-vize": "bin/oxlint-vize"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei/vize",
+    "directory": "npm/oxlint-plugin-vize"
+  },
+  "keywords": [
+    "oxlint",
+    "plugin",
+    "vue",
+    "vize",
+    "lint"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "^1.53.0"
+  },
+  "optionalDependencies": {
+    "@vizejs/native-darwin-arm64": "0.48.0",
+    "@vizejs/native-darwin-x64": "0.48.0",
+    "@vizejs/native-linux-arm64-gnu": "0.48.0",
+    "@vizejs/native-linux-arm64-musl": "0.48.0",
+    "@vizejs/native-linux-x64-gnu": "0.48.0",
+    "@vizejs/native-linux-x64-musl": "0.48.0",
+    "@vizejs/native-win32-arm64-msvc": "0.48.0",
+    "@vizejs/native-win32-x64-msvc": "0.48.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.6.0",
+    "vite-plus": "latest",
+    "@vizejs/native": "0.48.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp pack && node --experimental-strip-types src/test.ts",
+    "check": "vp check src vite.config.ts",
+    "check:fix": "vp check --fix src vite.config.ts",
+    "fmt": "vp fmt --write src vite.config.ts"
+  }
+}