@tsrx/oxc 0.9.0 → 0.11.0

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://compiled.run/oxc-tsrx">
+  <a href="https://oxc.tsrx.dev">
     <img alt="OXC for TSRX" width="600" src="https://raw.githubusercontent.com/tsrx-org/oxc/HEAD/.github/assets/readme-hero.png">
   </a>
 </p>
@@ -26,7 +26,7 @@ written in Rust. This package teaches them to read `.tsrx` too.
 
 _OXC for TSRX is the official OXC integration maintained by the TSRX project._
 
-[**Docs**](https://compiled.run/oxc-tsrx) &nbsp;·&nbsp; [**Getting started**](https://compiled.run/oxc-tsrx/guide/getting-started) &nbsp;·&nbsp; [**Playground**](https://compiled.run/oxc-tsrx/playground)
+[**Docs**](https://oxc.tsrx.dev) &nbsp;·&nbsp; [**Getting started**](https://oxc.tsrx.dev/guide/getting-started) &nbsp;·&nbsp; [**Playground**](https://oxc.tsrx.dev/playground)
 
 ## Install
 
@@ -37,11 +37,11 @@ npm install --save-dev @tsrx/oxc
 That is the whole setup, for the command line and for your editor. You get
 `oxlint` and `oxfmt`, the real [OXC](https://oxc.rs) commands, now able to read
 `.tsrx`, with no config file, no ignore file, and no install script. [Vite+ needs
-one more command](https://compiled.run/oxc-tsrx/guide/getting-started#try-it-with-vite).
+one more command](https://oxc.tsrx.dev/guide/getting-started#try-it-with-vite).
 
 You do not need Rust installed: the install downloads a ready-built program for
 your machine, one of eight published for macOS, Linux, and Windows. See
-[Platform support](https://compiled.run/oxc-tsrx/reference/platform-support).
+[Platform support](https://oxc.tsrx.dev/reference/platform-support).
 
 ## Usage
 
@@ -64,7 +64,7 @@ These are the TSRX blocks the linter and formatter understand: `@{` blocks,
 `@if` / `@else if` / `@else`, `@for` / `@empty`, `@switch` / `@case` /
 `@default`, `@try` / `@pending` / `@catch`, tags whose name is an expression,
 `<{expression}>`, and plain `<style>` blocks
-([TSRX syntax](https://compiled.run/oxc-tsrx/guide/tsrx-syntax) shows each one). Anything
+([TSRX syntax](https://oxc.tsrx.dev/guide/tsrx-syntax) shows each one). Anything
 outside that list **fails closed**: the command stops and says what it found and
 where, rather than guessing and maybe producing wrong output.
 
@@ -82,7 +82,7 @@ underlines the same problems the terminal reports. One catch: the TSRX
 toolchain's own extension owns `.tsrx`, and the OXC extension lists no
 activation event for it, so it does not start on its own. Open any JavaScript,
 TypeScript, or JSON file in the project once, and `.tsrx` works for the rest of
-the session. See the [editor guide](https://compiled.run/oxc-tsrx/integrations/editor).
+the session. See the [editor guide](https://oxc.tsrx.dev/integrations/editor).
 
 ## Using it from your own code
 
@@ -94,7 +94,7 @@ import { format } from "@tsrx/oxc/format";
 
 The parser hands back the structure of your file and the formatter hands back
 tidied text, so you can build your own tools on the same reader the commands
-use. [Parsing](https://compiled.run/oxc-tsrx/guide/parsing) has the shape it returns.
+use. [Parsing](https://oxc.tsrx.dev/guide/parsing) has the shape it returns.
 None of these compiles `.tsrx` either; that stays your framework's TSRX
 plugin's job.
 
@@ -121,16 +121,16 @@ editor both say when they have done that, and
 so it refuses `jsPlugins` and names `oxlint` as the command that can.
 `@tsrx/oxc/lint/plugins-dev` is for *writing* a plugin, since it re-exports the
 `RuleTester` from `oxlint`. See [Custom JavaScript
-plugins](https://compiled.run/oxc-tsrx/integrations/custom-js-plugins).
+plugins](https://oxc.tsrx.dev/integrations/custom-js-plugins).
 
 ## Documentation
 
-- [Getting started](https://compiled.run/oxc-tsrx/guide/getting-started): install, first file, first run.
-- [Configuration](https://compiled.run/oxc-tsrx/integrations/configuration): every supported setting.
-- [CLI reference](https://compiled.run/oxc-tsrx/reference/cli): commands, flags, and exit codes.
-- [Platform support](https://compiled.run/oxc-tsrx/reference/platform-support): which of the eight published platforms are tested on every change.
-- [Limitations](https://compiled.run/oxc-tsrx/reference/limitations): what is not claimed yet.
-- [Provider protocol](https://compiled.run/oxc-tsrx/architecture/provider-protocol): the `oxc.provider` block, what reads it today, and how a plain install reaches released hosts.
+- [Getting started](https://oxc.tsrx.dev/guide/getting-started): install, first file, first run.
+- [Configuration](https://oxc.tsrx.dev/integrations/configuration): every supported setting.
+- [CLI reference](https://oxc.tsrx.dev/reference/cli): commands, flags, and exit codes.
+- [Platform support](https://oxc.tsrx.dev/reference/platform-support): which of the eight published platforms are tested on every change.
+- [Limitations](https://oxc.tsrx.dev/reference/limitations): what is not claimed yet.
+- [Provider protocol](https://oxc.tsrx.dev/architecture/provider-protocol): the `oxc.provider` block, what reads it today, and how a plain install reaches released hosts.
 
 `@tsrx/oxc` is the only package to depend on. The eight `@tsrx/oxc-*`
 packages are platform binaries in `optionalDependencies`, and you never name one

package/dist/bin/oxc-tsrx.js

@@ -20,7 +20,10 @@ setup, status, and remove are the temporary compatibility bridge for consumers
 whose resolver is not provider-aware yet. The bridge creates the exact
 oxc-parser, oxlint, and oxfmt package-name facades those consumers need, and one
 fourth slot for the editor. Transitive official packages in those exact slots are
-preserved and restored; direct or unrecognized packages are never replaced.
+preserved and restored; direct or unrecognized packages are never replaced. An
+official oxlint or oxfmt you declare yourself keeps its slot and its command
+name (reported as a collision, with what that means); setup still writes the
+editor slot so the official OXC extension serves .tsrx through this package.
 
 The editor slot is the one thing setup writes outside node_modules. When
 node_modules/.bin/oxlint belongs to another tool, the official OXC extension

package/dist/bin/oxlint.js

@@ -8,13 +8,16 @@ try {
 	const { decideCanonicalCommand, deferralNotice, runOfficialCommand } = await import("../canonical-command.js");
 	const args = process.argv.slice(2);
 	const decision = await decideCanonicalCommand("oxlint");
-	if (decision.owner === "project") {
+	if (args.some((argument) => argument.split("=", 1)[0] === "--lsp")) {
+		const { runOxlintLspMultiplexer } = await import("../oxlint-lsp-multiplexer.js");
+		process.exitCode = await runOxlintLspMultiplexer(args, decision.owner === "project" ? { canonical: {
+			binPath: decision.binPath,
+			version: decision.officialVersion
+		} } : {});
+	} else if (decision.owner === "project") {
 		const notice = deferralNotice(decision, args);
 		if (notice !== null) console.error(notice);
 		await runOfficialCommand(decision);
-	} else if (args.some((argument) => argument.split("=", 1)[0] === "--lsp")) {
-		const { runOxlintLspMultiplexer } = await import("../oxlint-lsp-multiplexer.js");
-		process.exitCode = await runOxlintLspMultiplexer(args);
 	} else {
 		const { canRunCanonicalOxlint, importDeclaredPackageBinary, planCanonicalOxlintComposition } = await import("../lint-invocation.js");
 		if (canRunCanonicalOxlint(args)) await importDeclaredPackageBinary("oxlint-current", "oxlint", import.meta.url);

package/dist/compat.d.ts

@@ -8,8 +8,22 @@ export type OxcTsrxCompatibilityState =
 export interface OxcTsrxCompatibilitySlot {
   readonly name: "oxc-parser" | "oxlint" | "oxfmt";
   readonly capability: "parser" | "lint" | "format";
+  /** The command name the slot's package publishes, or null for the parser slot. */
+  readonly binary: "oxlint" | "oxfmt" | null;
   readonly path: string;
   readonly state: OxcTsrxCompatibilityState;
+  /**
+   * Why a `collision` slot is left alone. `direct-dependency` is the project's
+   * own official package; `setup` works around it and the report explains it.
+   * The other kinds are trees the bridge no longer owns and `setup` refuses.
+   */
+  readonly collision?:
+    | "direct-dependency"
+    | "foreign-package"
+    | "reinstalled-over-facade"
+    | "facade-without-backup";
+  /** What occupies a `collision` slot, as its own package.json names it. */
+  readonly occupant?: { readonly name: string | null; readonly version: string | null };
   readonly replacedPackage?: {
     readonly name: string;
     readonly version: string;

package/dist/compat.js

@@ -561,14 +561,22 @@ async function inspectSlot(modules, slot, providerVersion, projectManifest) {
 	};
 	const manifest = await readJson(join(destination, "package.json")).catch(() => null);
 	const metadata = compatibilityMetadata(manifest);
+	const occupant = {
+		name: typeof manifest?.name === "string" ? manifest.name : null,
+		version: typeof manifest?.version === "string" ? manifest.version : null
+	};
+	const collision = (kind) => ({
+		slot,
+		destination,
+		state: "collision",
+		metadata: null,
+		collision: kind,
+		occupant
+	});
 	if (!metadata || metadata.capability !== slot.capability) {
-		if (manifest?.name === slot.name && typeof manifest.version === "string" && !directlySelected(projectManifest, slot.name)) {
-			if (await exists(backupPath(modules, slot))) return {
-				slot,
-				destination,
-				state: "collision",
-				metadata: null
-			};
+		if (manifest?.name === slot.name && typeof manifest.version === "string") {
+			if (directlySelected(projectManifest, slot.name)) return collision("direct-dependency");
+			if (await exists(backupPath(modules, slot))) return collision("reinstalled-over-facade");
 			return {
 				slot,
 				destination,
@@ -580,19 +588,9 @@ async function inspectSlot(modules, slot, providerVersion, projectManifest) {
 				}
 			};
 		}
-		return {
-			slot,
-			destination,
-			state: "collision",
-			metadata: null
-		};
+		return collision("foreign-package");
 	}
-	if (metadata.replacedPackage && !await exists(backupPath(modules, slot))) return {
-		slot,
-		destination,
-		state: "collision",
-		metadata: null
-	};
+	if (metadata.replacedPackage && !await exists(backupPath(modules, slot))) return collision("facade-without-backup");
 	return {
 		slot,
 		destination,
@@ -1345,12 +1343,17 @@ async function compatibilityStatus(options = {}) {
 		packageManager: await detectPackageManager(projectRoot, options.userAgent),
 		providerVersion: provider.manifest.version,
 		selectedFrom: provider.selectedFrom,
-		slots: slots.map(({ slot, destination, state, replacedPackage }) => ({
+		slots: slots.map(({ slot, destination, state, replacedPackage, collision, occupant }) => ({
 			name: slot.name,
 			capability: slot.capability,
+			binary: slot.binary,
 			path: destination,
 			state,
-			...replacedPackage ? { replacedPackage } : {}
+			...replacedPackage ? { replacedPackage } : {},
+			...collision ? {
+				collision,
+				occupant
+			} : {}
 		})),
 		editorSlot: await inspectEditorSlot(projectRoot, provider.root, modules, options),
 		languageSupport: await inspectLanguageSupport(projectRoot, modules)
@@ -1358,8 +1361,8 @@ async function compatibilityStatus(options = {}) {
 }
 async function setupCompatibility(options = {}) {
 	const status = await compatibilityStatus(options);
-	const collisions = status.slots.filter((slot) => slot.state === "collision");
-	if (collisions.length > 0) throw new Error(`refusing to replace unowned package slot(s): ${collisions.map((slot) => slot.name).join(", ")}. Installing on top of the existing node_modules does not free the slot, so run rm -rf node_modules, install again, and run ${PROVIDER} setup again`);
+	const refused = status.slots.filter((slot) => slot.state === "collision" && slot.collision !== "direct-dependency");
+	if (refused.length > 0) throw new Error(`refusing to replace unowned package slot(s): ${refused.map((slot) => slot.name).join(", ")}. Installing on top of the existing node_modules does not free the slot, so run rm -rf node_modules, install again, and run ${PROVIDER} setup again`);
 	const modules = join(status.projectRoot, "node_modules");
 	if (!await exists(modules)) throw new Error(`node_modules is missing under ${status.projectRoot}; install dependencies first`);
 	let tsconfigWrite = null;
@@ -1407,7 +1410,7 @@ async function setupCompatibility(options = {}) {
 		languageSupport,
 		...tsconfigWrite ? { tsconfigWrite } : {},
 		changed,
-		unchanged: [...status.slots.filter((slot) => slot.state === "active").map((slot) => slot.name), ...editorWritten ? [] : [status.editorSlot.name]]
+		unchanged: [...status.slots.filter((slot) => slot.state === "active" || slot.state === "collision").map((slot) => slot.name), ...editorWritten ? [] : [status.editorSlot.name]]
 	};
 }
 async function removeCompatibility(options = {}) {
@@ -1466,6 +1469,20 @@ async function removeCompatibility(options = {}) {
 		removed
 	};
 }
+/**
+* What a package-slot collision means for the reader, by kind. Only the direct
+* dependency gets prose in the report, because it is the one a reader can act on
+* two different ways and the one that used to be a silent failure: the command
+* names stay with their package, so the drop-in `oxlint`/`oxfmt` skip `.tsrx`
+* with nothing on the command line saying so under pnpm.
+*/
+const SLOT_COLLISION_EXPLANATION = Object.freeze({ "direct-dependency": (slot) => {
+	const version = slot.occupant?.version ? ` ${slot.occupant.version}` : "";
+	if (!slot.binary) return `${slot.name}${version} is declared in your package.json, so that slot is yours and was left alone. Import @tsrx/oxc/parser for .tsrx.`;
+	const leaf = slot.name === "oxlint" ? "oxc-tsrx-lint" : "oxc-tsrx-fmt";
+	const editor = slot.name === "oxlint" ? ` The editor is wired separately: with "${EDITOR_SLOT.key}" written, the official OXC extension serves .tsrx through this package and keeps ordinary files on your own oxlint.` : " The editor is unaffected: .tsrx formatting rides on the oxlint --lsp connection.";
+	return `${slot.name}${version} is declared in your package.json, so the ${slot.binary} command belongs to it: on the command line it runs exactly as it did before ${PROVIDER} was installed, and it does not read .tsrx files. Run ${leaf} for .tsrx, or remove the direct ${slot.name} dependency and let this package serve both, at the ${slot.name} version this package bundles rather than the one you pinned.${editor}`;
+} });
 const EDITOR_SLOT_EXPLANATION = Object.freeze({
 	active: (slot, projectRoot) => `${toPosix(relative(projectRoot, slot.path))} carries "${slot.key}": "${slot.value}". This is the one file setup writes outside node_modules; it merges that single key and never edits package.json or tsconfig.json.`,
 	stale: (slot, projectRoot) => `${toPosix(relative(projectRoot, slot.path))} carries a "${slot.key}" this package wrote that no longer resolves here; setup refreshes it to "${slot.value}".`,
@@ -1585,6 +1602,12 @@ function formatCompatibilityReport(result) {
 		const gutter = `  ${`${name}:`.padEnd(nameWidth + 1)}  `;
 		lines.push(`${gutter}${paint(label, SLOT_STATE_STYLE[state] ?? "cyan", color)}`);
 	}
+	for (const slot of result.slots) {
+		const explain = slot.state === "collision" ? SLOT_COLLISION_EXPLANATION[slot.collision] : null;
+		if (!explain) continue;
+		lines.push("");
+		for (const line of wrapReportText(explain(slot), "      ", "      ", width)) lines.push(paint(line, "dim", color));
+	}
 	if (editor) {
 		const explain = EDITOR_SLOT_EXPLANATION[editor.state];
 		if (explain) {

package/dist/format-cli.js

@@ -1,6 +1,6 @@
-import { resolvePackageBinary } from "./package-binary.js";
 import { runCaptured, runPassthrough } from "./process.js";
-import { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, isViteConfigPath, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeCommand } from "./runtime.js";
+import { resolvePackageBinary } from "./package-binary.js";
+import { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, isViteConfigPath, pathArguments, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeCommand } from "./runtime.js";
 import { VALUE_OPTIONS, parseOxfmtInvocation, parseOxfmtOption } from "./format-invocation.js";
 import { isAbsolute, relative } from "node:path";
 import { readFileSync } from "node:fs";
@@ -231,7 +231,7 @@ async function runCli(args, options = {}) {
 		}
 	}
 	const positions = invocation.positionals;
-	const files = await discoverTsrxFiles(positions, cwd);
+	const files = await discoverTsrxFiles(positions, cwd, "format");
 	if (files.length > 0 || hasTsrxPositional(positions)) {
 		const unknown = unknownCanonicalOption(args);
 		if (unknown !== null) {
@@ -242,13 +242,15 @@ async function runCli(args, options = {}) {
 	const explicitConfig = argumentValue(args, /* @__PURE__ */ new Set(["-c", "--config"]));
 	const bridgeViteConfig = explicitConfig === null || isViteConfigPath(explicitConfig);
 	const viteConfig = files.length > 0 && bridgeViteConfig ? await prepareVitePlusConfig("fmt", cwd, isViteConfigPath(explicitConfig) ? explicitConfig : null) : null;
+	let nativePaths = null;
 	try {
 		const stripped = removeExplicitTsrx(args, VALUE_OPTIONS);
 		const shouldRunUpstream = !stripped.hadPositionals || stripped.remainingPositionals > 0;
 		const upstream = resolvePackageBinary("oxfmt-current", "oxfmt", import.meta.url);
 		const useMaterializedUpstreamConfig = Boolean(viteConfig && !viteConfig.requiresAuthoredBase);
 		const upstreamArgs = useMaterializedUpstreamConfig ? replaceConfigArgument(stripped.args, viteConfig.path) : stripped.args;
-		const nativeArgs = files.length > 0 ? nativeArguments(args, withCwdRelativePaths(files, cwd), viteConfig) : null;
+		nativePaths = files.length > 0 ? await pathArguments(withCwdRelativePaths(files, cwd)) : null;
+		const nativeArgs = nativePaths ? nativeArguments(args, nativePaths.args, viteConfig) : null;
 		const nativeCommand = nativeArgs ? resolveNativeCommand("format", nativeArgs) : null;
 		const [upstreamResult, nativeResult] = await Promise.all([shouldRunUpstream ? runCaptured(process.execPath, [upstream, ...upstreamArgs], {
 			cwd,
@@ -269,6 +271,7 @@ async function runCli(args, options = {}) {
 		process.stderr.write(attributeNativeErrors(mergeFormatStderr(upstreamResult, nativeResult, stdout)));
 		return Math.max(upstreamResult.status, nativeResult.status);
 	} finally {
+		await nativePaths?.cleanup();
 		await viteConfig?.cleanup();
 	}
 }

package/dist/lint-cli.js

@@ -1,6 +1,6 @@
-import { resolvePackageBinary } from "./package-binary.js";
 import { runCaptured, runPassthrough } from "./process.js";
-import { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, ensureSupportedOutput, isViteConfigPath, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeCommand } from "./runtime.js";
+import { resolvePackageBinary } from "./package-binary.js";
+import { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, ensureSupportedOutput, isViteConfigPath, pathArguments, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeCommand } from "./runtime.js";
 import { DELEGATE_ONLY, VALUE_OPTIONS, parseOxlintInvocation, parseOxlintOption, withOxlintOutputFormat } from "./lint-invocation.js";
 import { jsPluginUnmappedNote, preparePluginLane } from "./lint-js-plugins.js";
 import { readFile } from "node:fs/promises";
@@ -379,6 +379,7 @@ async function runCli(args, options = {}) {
 	}
 	const pluginLaneActive = pluginLane?.status === "active";
 	if (pluginLaneActive && !args.includes("--silent")) process.stderr.write(`${pluginLane.notice}\n`);
+	let nativePaths = null;
 	try {
 		const stripped = removeExplicitTsrx(args, VALUE_OPTIONS);
 		const shouldRunUpstream = !stripped.hadPositionals || stripped.remainingPositionals > 0;
@@ -396,7 +397,8 @@ async function runCli(args, options = {}) {
 		let upstreamArgs = withOxlintOutputFormat(stripped.args, "json");
 		if (useMaterializedUpstreamConfig) upstreamArgs = replaceConfigArgument(upstreamArgs, viteConfig.path);
 		const nativeResolvedConfig = pluginLane?.nativeConfig ?? viteConfig;
-		const nativeArgs = files.length > 0 ? nativeArguments(args, files, nativeResolvedConfig) : null;
+		nativePaths = files.length > 0 ? await pathArguments(files) : null;
+		const nativeArgs = nativePaths ? nativeArguments(args, nativePaths.args, nativeResolvedConfig) : null;
 		const nativeCommand = nativeArgs ? resolveNativeCommand("lint", nativeArgs) : null;
 		let upstreamPromise;
 		if (!shouldRunUpstream) upstreamPromise = Promise.resolve({
@@ -480,6 +482,7 @@ async function runCli(args, options = {}) {
 		return Math.max(upstreamResult.status, nativeResult.status, denyWarnings && warnings > 0 ? 1 : 0, exceedsMaximum ? 1 : 0, pluginErrors ? 1 : 0);
 	} finally {
 		await pluginLane?.cleanup?.();
+		await nativePaths?.cleanup();
 		await viteConfig?.cleanup();
 	}
 }

package/dist/lint-js-plugins.js

@@ -1,6 +1,6 @@
-import { resolvePackageBinary } from "./package-binary.js";
 import { runCaptured } from "./process.js";
-import { resolveNativeCommand } from "./runtime.js";
+import { resolvePackageBinary } from "./package-binary.js";
+import { pathArguments, resolveNativeCommand } from "./runtime.js";
 import { createRequire } from "node:module";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
@@ -434,8 +434,14 @@ async function preparePluginLane({ cwd, files, viteConfig, explicitConfig }) {
 async function emitProjections(cwd, files, nativeConfig) {
 	const args = ["--emit-plugin-projection"];
 	if (nativeConfig) args.push("--config", nativeConfig.path, "--config-base", nativeConfig.base);
-	const command = resolveNativeCommand("lint", [...args, ...files]);
-	const result = await runCaptured(command.executable, command.args, { cwd });
+	const paths = await pathArguments(files);
+	let result;
+	try {
+		const command = resolveNativeCommand("lint", [...args, ...paths.args]);
+		result = await runCaptured(command.executable, command.args, { cwd });
+	} finally {
+		await paths.cleanup();
+	}
 	if (result.status !== 0) throw new Error(`the native TSRX projection needed for JS plugins failed:\n${result.stderr || result.stdout}`);
 	let parsed;
 	try {

package/dist/lint-prestart.js

@@ -1,5 +1,5 @@
-import { resolvePackageBinary } from "./package-binary.js";
 import { runCaptured } from "./process.js";
+import { resolvePackageBinary } from "./package-binary.js";
 //#region src/lint-prestart.ts
 function startCanonicalOxlint(args, cwd = process.cwd(), env = process.env) {
 	const binary = resolvePackageBinary("oxlint-current", "oxlint", import.meta.url);

package/dist/oxlint-lsp-multiplexer.js

@@ -566,6 +566,11 @@ async function runOxlintLspMultiplexer(args, options = {}) {
 	const spawnProcess = options.spawn ?? spawn;
 	const clientError = options.clientError ?? process.stderr;
 	const cwd = options.cwd ?? process.cwd();
+	const canonicalBinary = options.canonical?.binPath ?? resolveCanonicalOxlintBinary();
+	if (options.canonical?.binPath) {
+		const version = options.canonical.version ? ` ${options.canonical.version}` : "";
+		clientError.write(`oxlint (oxc-tsrx): ordinary documents are served by the official oxlint${version} this project declares (${options.canonical.binPath}); .tsrx documents by the native server\n`);
+	}
 	const childOptions = {
 		cwd,
 		env: {
@@ -584,7 +589,7 @@ async function runOxlintLspMultiplexer(args, options = {}) {
 		cwd: index.root
 	} : childOptions;
 	const providers = providerLspSessions(index, spawnProcess, providerOptions);
-	const canonical = spawnProcess(process.execPath, [resolveCanonicalOxlintBinary(), ...args], childOptions);
+	const canonical = spawnProcess(process.execPath, [canonicalBinary, ...args], childOptions);
 	const multiplexer = createOxlintLspMultiplexer({
 		providerRoot: providerOptions === childOptions ? null : index.root,
 		clientInput: options.clientInput ?? process.stdin,

package/dist/parser.js

@@ -3,7 +3,7 @@ import { isTsrxBinaryProgram, parseTrustedTsrxProgram, parseTsrxProgram } from "
 import { createRequire } from "node:module";
 //#region src/parser.ts
 const require = createRequire(import.meta.url);
-const PACKAGE_VERSION = "0.9.0";
+const PACKAGE_VERSION = "0.11.0";
 const parserManifest = Object.freeze({
 	name: "@tsrx/oxc",
 	version: PACKAGE_VERSION,

package/dist/runtime.js

@@ -1,6 +1,6 @@
 import { nativePackageName, nativeTargetForHost } from "./native-targets.js";
-import { resolvePackageBinary } from "./package-binary.js";
 import { runCaptured, runPassthrough } from "./process.js";
+import { resolvePackageBinary } from "./package-binary.js";
 import { createRequire } from "node:module";
 import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, parse, resolve, sep } from "node:path";
@@ -254,7 +254,7 @@ function slash(path) {
 function hasMagic(path) {
 	return /[*?[\]{}()!]/u.test(path);
 }
-async function classifyPattern(raw, cwd, positives, patterns) {
+async function classifyPattern(raw, cwd, positives, patterns, directories) {
 	const negative = raw.startsWith("!");
 	const value = negative ? raw.slice(1) : raw;
 	const absolute = isAbsolute(value) ? value : resolve(cwd, value);
@@ -266,31 +266,93 @@ async function classifyPattern(raw, cwd, positives, patterns) {
 			return;
 		}
 		if (metadata.isDirectory()) {
-			patterns.push(`${negative ? "!" : ""}${slash(join(absolute, "**/*.tsrx"))}`);
+			if (negative) patterns.push(`!${slash(join(absolute, "**/*.tsrx"))}`);
+			else directories.push(absolute);
 			return;
 		}
 	} catch {}
 	patterns.push(`${negative ? "!" : ""}${slash(value)}`);
 }
-async function classifyPatterns(inputs, cwd, positives, patterns) {
+async function classifyPatterns(inputs, cwd, positives, patterns, directories) {
 	const classified = await Promise.all(inputs.map(async (input) => {
 		const entryPositives = /* @__PURE__ */ new Set();
 		const entryPatterns = [];
-		await classifyPattern(input, cwd, entryPositives, entryPatterns);
+		const entryDirectories = [];
+		await classifyPattern(input, cwd, entryPositives, entryPatterns, entryDirectories);
 		return {
 			entryPositives,
-			entryPatterns
+			entryPatterns,
+			entryDirectories
 		};
 	}));
-	for (const { entryPositives, entryPatterns } of classified) {
+	for (const { entryPositives, entryPatterns, entryDirectories } of classified) {
 		for (const positive of entryPositives) positives.add(positive);
 		for (const pattern of entryPatterns) patterns.push(pattern);
+		for (const directory of entryDirectories) directories.push(directory);
+	}
+}
+/**
+* A file list as arguments the native leaf accepts. A short list travels on the
+* command line as before. A long one is written to a temporary file and named
+* with `--paths-file`, because a host's argument limit is reached by a real
+* repository (E2BIG past about a megabyte on macOS and Linux, a 32 KiB command
+* line on Windows, which a few hundred paths fill). The caller disposes of it.
+*/
+async function pathArguments(files, budget = 24e3) {
+	if (files.reduce((total, file) => total + Buffer.byteLength(file) + 1, 0) <= budget) return {
+		args: [...files],
+		cleanup: async () => {}
+	};
+	const directory = await mkdtemp(join(tmpdir(), "oxc-tsrx-paths-"));
+	const path = join(directory, "paths.txt");
+	await writeFile(path, `${files.join("\n")}\n`);
+	return {
+		args: ["--paths-file", path],
+		cleanup: () => rm(directory, {
+			recursive: true,
+			force: true
+		})
+	};
+}
+/**
+* Directories are walked by the native leaf, on the same `ignore` crate
+* canonical Oxlint walks with, so `.gitignore` and `.ignore` files are honoured
+* and `node_modules` and `.git` are never entered. Without that, a monorepo
+* that keeps gitignored copies of itself handed every one of them to the leaf.
+* Returns null when no native package is installed, and the caller falls back
+* to the plain glob so the run can still reach the error that names the missing
+* package.
+*/
+async function walkWithNativeLeaf(directories, cwd, kind) {
+	let command;
+	try {
+		command = resolveNativeCommand(kind, ["--discover"]);
+	} catch {
+		return null;
+	}
+	const paths = await pathArguments(directories);
+	try {
+		const result = await runCaptured(command.executable, [...command.args, ...paths.args], { cwd });
+		if (result.status !== 0) throw new Error(`.tsrx discovery failed: ${(result.stderr || result.stdout).trim()}`);
+		const report = JSON.parse(result.stdout);
+		if (!Array.isArray(report?.files)) throw new Error(".tsrx discovery returned no file list");
+		return report.files.map((file) => resolve(file));
+	} finally {
+		await paths.cleanup();
 	}
 }
-async function discoverTsrxFiles(positionals, cwd = process.cwd()) {
+/**
+* `kind` names the leaf that walks directories, `lint` or `format`: both
+* answer `--discover` identically, and each command resolves its own binary.
+*/
+async function discoverTsrxFiles(positionals, cwd = process.cwd(), kind = "lint") {
 	const positives = /* @__PURE__ */ new Set();
 	const patterns = [];
-	await classifyPatterns(positionals.length === 0 ? ["."] : positionals, cwd, positives, patterns);
+	const directories = [];
+	await classifyPatterns(positionals.length === 0 ? ["."] : positionals, cwd, positives, patterns, directories);
+	const walked = directories.length > 0 && !patterns.some((pattern) => pattern.startsWith("!")) ? await walkWithNativeLeaf(directories, cwd, kind) : null;
+	if (walked === null) for (const directory of directories) patterns.push(slash(join(directory, "**/*.tsrx")));
+	else for (const file of walked) positives.add(file);
 	if (patterns.length > 0) {
 		const { glob } = await import("tinyglobby");
 		const matches = await glob(patterns, {
@@ -320,4 +382,4 @@ function ensureSupportedOutput(format, files) {
 	if (files.length > 0 && format !== "default" && format !== "json") throw new Error(`OXC for TSRX currently combines default and json lint output; ${format} is unavailable for mixed .tsrx runs`);
 }
 //#endregion
-export { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, ensureSupportedOutput, isViteConfigPath, platformPackage, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeBinary, resolveNativeCommand, resolvePackageBinary, runCaptured, runPassthrough };
+export { argumentValue, canonicalToolEnvironment, discoverTsrxFiles, ensureSupportedOutput, isViteConfigPath, pathArguments, platformPackage, prepareVitePlusConfig, removeExplicitTsrx, replaceConfigArgument, resolveNativeBinary, resolveNativeCommand, resolvePackageBinary, runCaptured, runPassthrough };

package/dist/tsrx-core-compat/facade.js

@@ -949,7 +949,7 @@ function materializeCompatibilityProgram(program, source, filename, loose, posit
 			if (value.pending != null && value.pendingKeyword == null) value.pendingKeyword = keywordSpan(source, "@pending", value.block?.end ?? value.start, value.pending?.end ?? value.end, positionAt);
 			if (value.handler != null && value.handlerKeyword == null) value.handlerKeyword = keywordSpan(source, "@catch", value.pending?.end ?? value.block?.end ?? value.start, value.handler?.end ?? value.end, positionAt);
 		}
-		if (value.type === "JSXStyleElement" && typeof value.css === "string") {
+		if (value.type === "JSXStyleElement" && typeof value.css === "string" && value.openingElement?.selfClosing !== true) {
 			const style = parse_style(value.css, {
 				filename,
 				line: value.openingElement?.loc?.start?.line ?? value.loc?.start?.line ?? 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsrx/oxc",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The official OXC integration for TSRX — Rust-native Oxlint and Oxfmt for .tsrx, JavaScript, TypeScript, and JSX",
   "keywords": [
     "formatter",
@@ -14,7 +14,7 @@
     "tsrx",
     "typescript"
   ],
-  "homepage": "https://compiled.run/oxc-tsrx",
+  "homepage": "https://oxc.tsrx.dev",
   "bugs": {
     "url": "https://github.com/tsrx-org/oxc/issues"
   },
@@ -128,14 +128,14 @@
     "tinyglobby": "0.2.17"
   },
   "optionalDependencies": {
-    "@tsrx/oxc-darwin-arm64": "0.9.0",
-    "@tsrx/oxc-darwin-x64": "0.9.0",
-    "@tsrx/oxc-linux-arm64-gnu": "0.9.0",
-    "@tsrx/oxc-linux-arm64-musl": "0.9.0",
-    "@tsrx/oxc-linux-x64-gnu": "0.9.0",
-    "@tsrx/oxc-linux-x64-musl": "0.9.0",
-    "@tsrx/oxc-win32-arm64-msvc": "0.9.0",
-    "@tsrx/oxc-win32-x64-msvc": "0.9.0"
+    "@tsrx/oxc-darwin-arm64": "0.11.0",
+    "@tsrx/oxc-darwin-x64": "0.11.0",
+    "@tsrx/oxc-linux-arm64-gnu": "0.11.0",
+    "@tsrx/oxc-linux-arm64-musl": "0.11.0",
+    "@tsrx/oxc-linux-x64-gnu": "0.11.0",
+    "@tsrx/oxc-linux-x64-musl": "0.11.0",
+    "@tsrx/oxc-win32-arm64-msvc": "0.11.0",
+    "@tsrx/oxc-win32-x64-msvc": "0.11.0"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"