@rdjperron/lint 0.3.0 → 0.5.0

package/dist/verify.d.mts

@@ -1,92 +1 @@
-//#region src/verify.d.ts
-/**
- * Proof that every lint rule still fires.
- *
- * The linter lives inside the `vp` binary, so it moves independently of any
- * lockfile, and the JS-plugin bridge it loads these rules through is alpha. A
- * rule can stop firing with no diff anywhere, and a dead lint rule is silent:
- * "reports nothing" looks exactly like "no violations". This is the thing that
- * notices.
- *
- * A suite is a directory holding one deliberately-broken `<rule>.fixture.ts(x)`
- * per rule. The check asserts a positive: every rule fired, each on the file
- * named after it.
- *
- * Run the package's own suite from a consumer's repo root:
- *
- *     npx rdjperron-lint-verify
- *
- * ---------------------------------------------------------------------------
- * Why the symlink dance
- * ---------------------------------------------------------------------------
- * The fixtures ship inside `node_modules`, which oxlint never walks, and a
- * consumer's own fixture directories are usually in `lint.ignorePatterns` so a
- * plain `vp check` stays quiet. Measured on Vite+ 0.2.9 / oxlint 1.77.0 and
- * again on 0.3.1 / oxlint 1.81.0: no flag re-includes an ignored path.
- * `--no-ignore`, `--ignore-pattern '!<dir>/**'`, an explicit file, an absolute
- * path, a cwd inside the directory and `-W <rule>` all answer "No files found
- * to lint." `--no-ignore` only disables `.eslintignore`, `--ignore-path` and
- * `--ignore-pattern`; it does not touch the config's own `ignorePatterns`, and
- * `vp lint` has no `--config` flag.
- *
- * What does work: oxlint matches ignore patterns against the path it walked,
- * not the realpath. Linting through a symlink outside the ignored prefix
- * reaches the fixtures normally, plugin and all. This creates that view per
- * suite, lints through it, and removes it in a `finally`.
- *
- * The severities cannot come from the command line either: `-A`, `-W` and `-D`
- * reach built-in rules only and leave every JS plugin rule exactly as the config
- * left it (measured on vite-plus 0.3.1 / oxlint 1.81.0, with `vp lint` and with
- * the bare binary). That is why the consumer's config must carry the
- * `fixtures()` override from `@rdjperron/lint/config`.
- */
-export interface Suite {
-  /** The plugin alias the diagnostics carry, e.g. `rdjperron` in `rdjperron(no-reflect-get)`. */
-  plugin: string;
-  /** The fixture directory, relative to `root`. */
-  fixtureDir: string;
-  /** Where the un-ignored view is created, relative to `root`. */
-  viewDir: string;
-  /** Fixture file endings; the part before one of them is the rule name. */
-  suffixes?: string[];
-  /** Skip the direct path and always lint through the view (fixtures under `node_modules`). */
-  alwaysView?: boolean;
-  /** Advisory: the rule names the plugin registers, so a new rule without a fixture is named. */
-  registeredRules?: () => Promise<string[] | null>;
-  /** Where the failure message sends the reader. */
-  readme?: string;
-}
-export interface VerifyOptions {
-  /** The repo root the paths are relative to and `vp lint` runs from. Defaults to the cwd. */
-  root?: string;
-}
-/**
- * Locate the `vp` binary: PATH first, then the default install locations, the
- * XDG layout used since Vite+ 0.3.0 and the pre-0.3.0 single-root layout that
- * upgraded installs keep.
- */
-export declare function resolveViteplusBinary(): string;
-/**
- * Lint every suite and print one table each. Returns the number of rules that
- * did not fire, so zero means every rule of every suite is alive.
- */
-export declare function verifySuites(suites: Suite[], options?: VerifyOptions): Promise<number>;
-/**
- * Two promises about the plugin API, held here as a failure instead.
- *
- *   - the installed `@oxlint/plugins` is the exact version `vite-plus` declares;
- *   - this package's peer range accepts that version.
- *
- * The rules import `@oxlint/plugins`, so the installed one must be the one the
- * linter was built against, or the rules compile against one plugin API and run
- * under another with no error anywhere. Returns the failures, empty when the
- * pins agree or when `vite-plus` is not installed (a consumer on another
- * toolchain has nothing to pin against).
- */
-export declare function verifyPluginApiPin(root?: string): string[];
-/** The suite for this package's own fixtures, as they sit in a consumer's `node_modules`. */
-export declare function packageSuite(root?: string): Suite;
-/** The bin: this package's suite, plus the plugin API pin, from the consumer's repo root. */
-export declare function main(root?: string): Promise<number>;
-//#endregion
-//# sourceMappingURL=verify.d.mts.map
+export {}

package/dist/verify.mjs

@@ -1,52 +1,37 @@
 #!/usr/bin/env node
+import { s as plugin, t as RULE_IDS } from "./config-CD2iCM6L.mjs";
 import { createRequire } from "node:module";
 import { spawnSync } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, symlinkSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { cpSync, existsSync, mkdtempSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/verify.ts
 /**
-* Proof that every lint rule still fires.
+* Proof that every rule of this plugin still fires.
 *
-* The linter lives inside the `vp` binary, so it moves independently of any
-* lockfile, and the JS-plugin bridge it loads these rules through is alpha. A
-* rule can stop firing with no diff anywhere, and a dead lint rule is silent:
-* "reports nothing" looks exactly like "no violations". This is the thing that
-* notices.
+* A dead lint rule is silent: "reports nothing" reads exactly like "no
+* violations", so nothing else in a repo notices when a linter upgrade, a
+* JS-plugin API change or an ignore pattern takes a rule out. This lints one
+* deliberately-broken fixture per rule and asserts a positive: every rule fired,
+* each on the file named after it.
 *
-* A suite is a directory holding one deliberately-broken `<rule>.fixture.ts(x)`
-* per rule. The check asserts a positive: every rule fired, each on the file
-* named after it.
+* It runs in a throwaway project under the system temp directory: its own
+* generated config with every rule at error, the shipped fixtures copied in, and
+* the caller's `node_modules` symlinked beside them. The caller's own config
+* takes no part, so the answer is about the plugin and the linter alone and a
+* consumer has nothing to write.
 *
-* Run the package's own suite from a consumer's repo root:
+* The linter is the oxlint the LOCAL `vite-plus` depends on, so it follows the
+* lockfile rather than the `vp` on PATH (measured 2026-09-19: a global `vp`
+* 0.3.1 over a local `vite-plus` 0.2.9 ran oxlint 1.77.0). The run that earns
+* this check its place is therefore the commit that moves `vite-plus`, and CI.
 *
 *     npx rdjperron-lint-verify
-*
-* ---------------------------------------------------------------------------
-* Why the symlink dance
-* ---------------------------------------------------------------------------
-* The fixtures ship inside `node_modules`, which oxlint never walks, and a
-* consumer's own fixture directories are usually in `lint.ignorePatterns` so a
-* plain `vp check` stays quiet. Measured on Vite+ 0.2.9 / oxlint 1.77.0 and
-* again on 0.3.1 / oxlint 1.81.0: no flag re-includes an ignored path.
-* `--no-ignore`, `--ignore-pattern '!<dir>/**'`, an explicit file, an absolute
-* path, a cwd inside the directory and `-W <rule>` all answer "No files found
-* to lint." `--no-ignore` only disables `.eslintignore`, `--ignore-path` and
-* `--ignore-pattern`; it does not touch the config's own `ignorePatterns`, and
-* `vp lint` has no `--config` flag.
-*
-* What does work: oxlint matches ignore patterns against the path it walked,
-* not the realpath. Linting through a symlink outside the ignored prefix
-* reaches the fixtures normally, plugin and all. This creates that view per
-* suite, lints through it, and removes it in a `finally`.
-*
-* The severities cannot come from the command line either: `-A`, `-W` and `-D`
-* reach built-in rules only and leave every JS plugin rule exactly as the config
-* left it (measured on vite-plus 0.3.1 / oxlint 1.81.0, with `vp lint` and with
-* the bare binary). That is why the consumer's config must carry the
-* `fixtures()` override from `@rdjperron/lint/config`.
 */
-const DEFAULT_SUFFIXES = [".fixture.ts", ".fixture.tsx"];
+const FIXTURE_SUFFIXES = [".fixture.ts", ".fixture.tsx"];
+/** Relative to this module, so it resolves from `dist/verify.mjs` and from `src/verify.ts` alike. */
+const FIXTURES_DIR = fileURLToPath(new URL("../fixtures", import.meta.url));
 /** Deterministic, locale-independent ordering for the rule and file name lists. */
 function byName(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
@@ -67,6 +52,17 @@ function resolveViteplusBinary() {
 	if (found !== void 0) return found;
 	throw new Error("Could not find the `vp` binary. Add it to PATH: export PATH=\"$HOME/.local/share/vite-plus/bin:$PATH\" (or \"$HOME/.vite-plus/bin\" for a pre-0.3.0 install)");
 }
+/** The `vite-plus` whose oxlint will run, and the `node_modules` the project borrows. */
+function resolveConsumerModules(root) {
+	const modules = join(root, "node_modules");
+	if (!existsSync(modules)) throw new Error(`No node_modules in ${root}. Install the dependencies and run this again.`);
+	try {
+		createRequire(join(root, "package.json")).resolve("vite-plus/package.json");
+	} catch {
+		throw new Error(`\`vite-plus\` is not installed in ${root}. The linter this check runs is the oxlint the local \`vite-plus\` depends on, so without it there is nothing to prove the rules against.`);
+	}
+	return modules;
+}
 /**
 * `vp lint -f json` is an outside value, so this is the one place its shape is
 * checked. Anything that does not look like a diagnostic is dropped rather than
@@ -92,8 +88,8 @@ function decodeReport(json) {
 		diagnostics
 	};
 }
-/** Run `vp lint <target> -f json` from `root` and return the decoded report. */
-function lintAsJson(binary, root, target) {
+/** Run `vp lint <target> -f json` from `cwd` and return the decoded report. */
+function lintAsJson(binary, cwd, target) {
 	const result = spawnSync(binary, [
 		"lint",
 		target,
@@ -101,7 +97,7 @@ function lintAsJson(binary, root, target) {
 		"json",
 		"--no-error-on-unmatched-pattern"
 	], {
-		cwd: root,
+		cwd,
 		encoding: "utf8",
 		maxBuffer: 67108864
 	});
@@ -116,106 +112,100 @@ function lintAsJson(binary, root, target) {
 		throw new Error(`Could not read \`vp lint\` JSON output: ${reason}\nstdout: ${stdout}`, { cause });
 	}
 }
-/**
-* Why a path is gitignored, or null. oxlint honours `.gitignore`, so a
-* gitignored view yields "0 files" instead of a useful diagnostic.
-*/
-function gitIgnoreReason(root, relPath) {
-	const result = spawnSync("git", [
-		"check-ignore",
-		"-v",
-		relPath
-	], {
-		cwd: root,
-		encoding: "utf8"
-	});
-	const output = result.status === 0 ? result.stdout.trim() : "";
-	return output === "" ? null : output.split("	")[0] ?? null;
-}
-/** Rule name to fixture file name, taken from the files that exist on disk. */
-function fixtureFiles(root, suite) {
-	const dir = join(root, suite.fixtureDir);
-	if (!existsSync(dir)) throw new Error(`Fixture directory is missing: ${dir}`);
-	const suffixes = suite.suffixes ?? DEFAULT_SUFFIXES;
+/** Rule name to fixture file name, taken from the files that ship with the package. */
+function fixtureFiles() {
+	if (!existsSync(FIXTURES_DIR)) throw new Error(`Fixture directory is missing: ${FIXTURES_DIR}`);
 	const files = /* @__PURE__ */ new Map();
-	for (const name of readdirSync(dir).toSorted(byName)) {
-		const suffix = suffixes.find((candidate) => name.endsWith(candidate));
+	for (const name of readdirSync(FIXTURES_DIR).toSorted(byName)) {
+		const suffix = FIXTURE_SUFFIXES.find((candidate) => name.endsWith(candidate));
 		if (suffix === void 0) continue;
 		files.set(name.slice(0, -suffix.length), name);
 	}
 	return files;
 }
-/** Create the un-ignored view; prefer a symlink, fall back to a copy on Windows. */
-function createFixtureView(root, suite) {
-	removeFixtureView(root, suite);
-	const viewPath = join(root, suite.viewDir);
-	mkdirSync(dirname(viewPath), { recursive: true });
+/** The throwaway project: a config naming every rule at error, the fixtures, and the modules. */
+function createProject(modules, specifier) {
+	const dir = mkdtempSync(join(tmpdir(), "rdjperron-lint-verify-"));
+	const rules = Object.fromEntries(RULE_IDS.map((id) => [id, "error"]));
+	writeFileSync(join(dir, "package.json"), `${JSON.stringify({
+		name: "rdjperron-lint-verify",
+		private: true,
+		type: "module"
+	}, null, 2)}\n`);
+	writeFileSync(join(dir, "vite.config.ts"), [
+		`import { defineConfig } from "vite-plus";`,
+		``,
+		`export default defineConfig({`,
+		`  lint: {`,
+		`    plugins: [],`,
+		`    jsPlugins: [${JSON.stringify({
+			name: plugin.name,
+			specifier
+		})}],`,
+		`    rules: ${JSON.stringify(rules, null, 2).replaceAll("\n", "\n    ")},`,
+		`  },`,
+		`});`,
+		``
+	].join("\n"));
+	cpSync(FIXTURES_DIR, join(dir, "fixtures"), { recursive: true });
+	symlinkSync(modules, join(dir, "node_modules"), "junction");
+	return dir;
+}
+/** `rdjperron(no-reflect-get)` -> `no-reflect-get`; a diagnostic from anything else -> null. */
+function ruleIdFor(code) {
+	const match = new RegExp(`^${plugin.name}\\(([^)]+)\\)$`, "u").exec(code);
+	return match === null ? null : match[1] ?? null;
+}
+/** The rule names the loaded plugin registers, or null when it cannot be imported. */
+async function registeredRules(specifier) {
 	try {
-		symlinkSync(join(root, suite.fixtureDir), viewPath, "junction");
-		return "symlink";
+		const rules = (await import(specifier)).default?.rules;
+		return typeof rules === "object" && rules !== null ? Object.keys(rules).toSorted(byName) : null;
 	} catch {
-		cpSync(join(root, suite.fixtureDir), viewPath, { recursive: true });
-		return "copy";
+		return null;
 	}
 }
-function removeFixtureView(root, suite) {
-	const viewPath = join(root, suite.viewDir);
-	rmSync(viewPath, {
-		recursive: true,
-		force: true
-	});
-	const top = resolve(root);
-	for (let dir = dirname(viewPath); dir !== top; dir = dirname(dir)) {
-		if (!existsSync(dir) || readdirSync(dir).length > 0) break;
-		rmdirSync(dir);
-	}
-}
-/** `rdjperron(no-reflect-get)` -> `no-reflect-get` for this suite's plugin; anything else -> null. */
-function ruleIdFor(plugin, code) {
-	const match = new RegExp(`^${plugin}\\(([^)]+)\\)$`, "u").exec(code);
-	return match === null ? null : match[1] ?? null;
+/** `--plugin <path>` points the run at a plugin on disk, which is how this repo checks its source. */
+function pluginSpecifier(argv) {
+	const index = argv.indexOf("--plugin");
+	if (index === -1) return plugin.specifier;
+	const value = argv[index + 1];
+	if (value === void 0) throw new Error("`--plugin` needs a path to the plugin module.");
+	return resolve(value);
 }
-/** Lint one suite and print its table. Returns the number of rules that did not fire. */
-async function verifySuite(binary, root, suite) {
-	const files = fixtureFiles(root, suite);
+async function main(argv) {
+	const specifier = pluginSpecifier(argv);
+	const binary = resolveViteplusBinary();
+	const modules = resolveConsumerModules(process.cwd());
+	const files = fixtureFiles();
 	const expectedRules = [...files.keys()];
-	console.log(`${suite.plugin} rule verification`);
-	console.log(`  fixtures:  ${suite.fixtureDir}`);
+	console.log(`${plugin.name} rule verification`);
+	console.log(`  plugin:    ${specifier}`);
+	console.log(`  fixtures:  ${FIXTURES_DIR}`);
 	if (expectedRules.length === 0) {
-		console.error(`  No fixture files found in ${suite.fixtureDir}. Nothing to verify.\n`);
+		console.error(`  No fixture files in ${FIXTURES_DIR}. Nothing to verify.\n`);
 		return 1;
 	}
-	let mechanism = "direct path";
-	let report = suite.alwaysView === true ? {
-		numberOfFiles: 0,
-		diagnostics: []
-	} : lintAsJson(binary, root, suite.fixtureDir);
-	if (report.numberOfFiles === 0) {
-		const kind = createFixtureView(root, suite);
-		try {
-			mechanism = `${kind} at ${suite.viewDir} (\`${suite.fixtureDir}\` is not walked by \`vp lint\`)`;
-			report = lintAsJson(binary, root, suite.viewDir);
-		} finally {
-			removeFixtureView(root, suite);
-		}
+	const project = createProject(modules, specifier);
+	let report;
+	try {
+		console.log(`  project:   ${project}`);
+		report = lintAsJson(binary, project, "fixtures");
+	} finally {
+		rmSync(project, {
+			recursive: true,
+			force: true
+		});
 	}
-	console.log(`  lint via:  ${mechanism}`);
-	console.log(`  files:     ${report.numberOfFiles}`);
-	console.log("");
+	console.log(`  files:     ${report.numberOfFiles}\n`);
 	if (report.numberOfFiles === 0) {
-		const ignoredBy = gitIgnoreReason(root, suite.viewDir);
-		console.error("FAIL: `vp lint` matched 0 files through both the direct path and the un-ignored view.\n" + (ignoredBy === null ? `Check that the config ignores the fixture directory itself and not a pattern such as
-"**/*.fixture.ts", which would also hide the view at "${suite.viewDir}".\nCheck too that the config carries the \`fixtures()\` override from @rdjperron/lint/config,
-on the view path: no command-line flag can switch a JS plugin rule on.
-` : `CAUSE: "${suite.viewDir}" is gitignored (${ignoredBy}). oxlint skips gitignored paths,\nso the view this lints through is invisible to it. Remove that ignore rule; the view is
-deleted in a \`finally\` block anyway.
-`));
+		console.error("FAIL: `vp lint` matched none of the fixtures in the throwaway project.\nNothing there is ignored and the fixtures are copied in, so this is `vp lint` refusing\nthe generated config rather than a rule going quiet.\n");
 		return expectedRules.length;
 	}
 	const firedByRule = /* @__PURE__ */ new Map();
 	const foreignDiagnostics = [];
 	for (const diagnostic of report.diagnostics) {
-		const ruleId = ruleIdFor(suite.plugin, diagnostic.code);
+		const ruleId = ruleIdFor(diagnostic.code);
 		if (ruleId === null) {
 			foreignDiagnostics.push(diagnostic);
 			continue;
@@ -245,156 +235,34 @@ deleted in a \`finally\` block anyway.
 	}
 	console.log("");
 	const failures = rows.filter((row) => !row.firedOnOwnFixture);
-	console.log(`${rows.length - failures.length}/${rows.length} ${suite.plugin} rules fired on their own fixture.`);
-	const registered = suite.registeredRules === void 0 ? null : await suite.registeredRules();
+	console.log(`${rows.length - failures.length}/${rows.length} ${plugin.name} rules fired on their own fixture.`);
+	const registered = await registeredRules(specifier);
 	if (registered !== null) {
 		const missingFixture = registered.filter((rule) => !expectedRules.includes(rule));
 		const orphanFixture = expectedRules.filter((rule) => !registered.includes(rule));
-		if (missingFixture.length > 0) console.log(`\nWARN: registered by the ${suite.plugin} plugin but has no fixture: ${missingFixture.join(", ")}`);
-		if (orphanFixture.length > 0) console.log(`\nWARN: fixture exists but the ${suite.plugin} plugin registers no such rule: ${orphanFixture.join(", ")}`);
+		if (missingFixture.length > 0) console.log(`\nWARN: registered by the ${plugin.name} plugin but has no fixture: ${missingFixture.join(", ")}`);
+		if (orphanFixture.length > 0) console.log(`\nWARN: fixture exists but the ${plugin.name} plugin registers no such rule: ${orphanFixture.join(", ")}`);
 	}
 	if (foreignDiagnostics.length > 0) {
-		console.log(`\nWARN: ${foreignDiagnostics.length} non-${suite.plugin} diagnostic(s) in the fixtures:`);
+		console.log(`\nWARN: ${foreignDiagnostics.length} non-${plugin.name} diagnostic(s) in the fixtures:`);
 		for (const diagnostic of foreignDiagnostics.slice(0, 20)) console.log(`  ${basename(diagnostic.filename)}: ${diagnostic.code}`);
 	}
 	if (failures.length > 0) {
-		const where = suite.readme === void 0 ? "" : ` See ${suite.readme}.`;
-		console.error(`\nFAIL: ${failures.length} ${suite.plugin} rule(s) did not fire.${where}\nFirst thing to check: the config's override on "${suite.viewDir}" has to put every rule\nat error. For this plugin that override is \`fixtures()\` from @rdjperron/lint/config; no
-command-line flag can switch a JS plugin rule on.`);
-	}
-	console.log("");
-	return failures.length;
-}
-/**
-* Lint every suite and print one table each. Returns the number of rules that
-* did not fire, so zero means every rule of every suite is alive.
-*/
-async function verifySuites(suites, options = {}) {
-	const root = resolve(options.root ?? process.cwd());
-	const binary = resolveViteplusBinary();
-	let failures = 0;
-	try {
-		for (const suite of suites) failures += await verifySuite(binary, root, suite);
-	} finally {
-		for (const suite of suites) removeFixtureView(root, suite);
+		console.error(`\nFAIL: ${failures.length} ${plugin.name} rule(s) did not fire. See ${join(FIXTURES_DIR, "README.md")}.\nEvery rule was at error in the generated config, so a rule that stayed quiet is one this
+linter did not run, not one this config left off.`);
+		return failures.length;
 	}
-	if (failures > 0) {
-		console.error(`FAIL: ${failures} rule(s) did not fire across ${suites.length} suite(s).`);
-		return failures;
-	}
-	console.log(`OK: every rule of every suite (${suites.map((suite) => suite.plugin).join(", ")}) still fires.`);
+	console.log(`\nOK: every ${plugin.name} rule still fires.`);
 	return 0;
 }
-const PLUGINS_PACKAGE = "@oxlint/plugins";
-function readManifest(path) {
-	const parsed = JSON.parse(readFileSync(path, "utf8"));
-	if (typeof parsed !== "object" || parsed === null) throw new Error(`Not a manifest: ${path}`);
-	const entry = parsed;
-	return {
-		version: typeof entry.version === "string" ? entry.version : "",
-		declaredPlugins: entry.dependencies?.[PLUGINS_PACKAGE] ?? "",
-		peerPlugins: entry.peerDependencies?.[PLUGINS_PACKAGE] ?? ""
-	};
-}
-/** The nearest `package.json` at or above a resolved module file. */
-function manifestNear(modulePath) {
-	let dir = dirname(modulePath);
-	for (;;) {
-		const candidate = join(dir, "package.json");
-		if (existsSync(candidate)) return candidate;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-/** `^x.y.z` is satisfied by the same major, at or above the base. */
-function caretAccepts(range, version) {
-	const match = /^\^(\d+)\.(\d+)\.(\d+)$/u.exec(range);
-	if (match === null) throw new Error(`Expected a caret range, got "${range}"`);
-	const [major, minor, patch] = match.slice(1).map(Number);
-	const [candidateMajor, candidateMinor, candidatePatch] = version.split(".").map(Number);
-	if (candidateMajor !== major) return false;
-	if (candidateMinor !== minor) return (candidateMinor ?? 0) > (minor ?? 0);
-	return (candidatePatch ?? 0) >= (patch ?? 0);
-}
-/**
-* Two promises about the plugin API, held here as a failure instead.
-*
-*   - the installed `@oxlint/plugins` is the exact version `vite-plus` declares;
-*   - this package's peer range accepts that version.
-*
-* The rules import `@oxlint/plugins`, so the installed one must be the one the
-* linter was built against, or the rules compile against one plugin API and run
-* under another with no error anywhere. Returns the failures, empty when the
-* pins agree or when `vite-plus` is not installed (a consumer on another
-* toolchain has nothing to pin against).
-*/
-function verifyPluginApiPin(root = process.cwd()) {
-	const requireFromRoot = createRequire(join(resolve(root), "package.json"));
-	const requireFromHere = createRequire(import.meta.url);
-	let vitePlus;
-	try {
-		vitePlus = readManifest(requireFromRoot.resolve("vite-plus/package.json"));
-	} catch {
-		console.log("plugin API pin: skipped, `vite-plus` is not installed here.");
-		return [];
-	}
-	const declared = vitePlus.declaredPlugins.replace(/^=/u, "");
-	if (!/^\d+\.\d+\.\d+$/u.test(declared)) return [`vite-plus ${vitePlus.version} no longer declares an exact @oxlint/plugins version.`];
-	let installed;
-	try {
-		const manifest = manifestNear(requireFromRoot.resolve("@oxlint/plugins"));
-		if (manifest === null) throw new Error("no package.json above @oxlint/plugins");
-		installed = readManifest(manifest);
-	} catch {
-		return ["`@oxlint/plugins` is not installed. It is a peer dependency of @rdjperron/lint."];
-	}
-	const self = readManifest(requireFromHere.resolve("../package.json"));
-	const peer = self.peerPlugins;
-	const failures = [];
-	if (installed.version !== declared) failures.push(`@oxlint/plugins ${installed.version} is installed and vite-plus ${vitePlus.version} declares ${declared}. Move the pin: install @oxlint/plugins@${declared} exactly.`);
-	if (!caretAccepts(peer, declared)) failures.push(`@rdjperron/lint ${self.version} wants @oxlint/plugins ${peer} and vite-plus ${vitePlus.version} declares ${declared}. Move one of the two pins.`);
-	if (failures.length === 0) console.log(`plugin API pin: @oxlint/plugins ${installed.version}, what vite-plus ${vitePlus.version} declares.`);
-	return failures;
-}
-/** The suite for this package's own fixtures, as they sit in a consumer's `node_modules`. */
-function packageSuite(root = process.cwd()) {
-	const packageDir = "node_modules/@rdjperron/lint";
-	return {
-		plugin: "rdjperron",
-		fixtureDir: `${packageDir}/fixtures`,
-		viewDir: "scripts/.lint-fixtures/rdjperron",
-		alwaysView: true,
-		readme: `${packageDir}/fixtures/README.md`,
-		registeredRules: async () => {
-			try {
-				const rules = (await import(createRequire(join(resolve(root), "package.json")).resolve("@rdjperron/lint"))).default?.rules;
-				return typeof rules === "object" && rules !== null ? Object.keys(rules).toSorted(byName) : null;
-			} catch {
-				return null;
-			}
-		}
-	};
-}
-/** The bin: this package's suite, plus the plugin API pin, from the consumer's repo root. */
-async function main(root = process.cwd()) {
-	const pinFailures = verifyPluginApiPin(root);
-	for (const failure of pinFailures) console.error(`FAIL: ${failure}`);
-	console.log("");
-	const ruleFailures = await verifySuites([packageSuite(root)], { root });
-	return pinFailures.length + ruleFailures > 0 ? 1 : 0;
-}
-const invoked = process.argv[1];
-if (invoked !== void 0 && existsSync(invoked) && realpathSync(invoked) === fileURLToPath(import.meta.url)) {
-	let exitCode = 1;
-	try {
-		exitCode = await main();
-	} catch (error) {
-		console.error(`\nFAIL: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	process.exit(exitCode);
+let exitCode = 1;
+try {
+	exitCode = await main(process.argv.slice(2));
+} catch (error) {
+	console.error(`\nFAIL: ${error instanceof Error ? error.message : String(error)}`);
 }
+process.exit(exitCode === 0 ? 0 : 1);
 //#endregion
-export { main, packageSuite, resolveViteplusBinary, verifyPluginApiPin, verifySuites };
+export {};
 
 //# sourceMappingURL=verify.mjs.map