@tsrx/oxc 0.0.0-trusted-publishing-bootstrap → 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OXC for TSRX contributors
+
+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,141 @@
+<p align="center">
+  <a href="https://compiled.run/oxc-tsrx">
+    <img alt="OXC for TSRX" width="600" src="https://raw.githubusercontent.com/tsrx-org/oxc/HEAD/.github/assets/readme-hero.png">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@tsrx/oxc"><img alt="npm version" src="https://img.shields.io/npm/v/@tsrx/oxc"></a>
+  <a href="https://nodejs.org/en/about/previous-releases"><img alt="supported Node.js versions" src="https://img.shields.io/node/v/@tsrx/oxc"></a>
+  <a href="https://github.com/tsrx-org/oxc/actions/workflows/ci.yml"><img alt="CI status" src="https://github.com/tsrx-org/oxc/actions/workflows/ci.yml/badge.svg?branch=main"></a>
+  <a href="https://discord.gg/HCYpT5QHQR"><img alt="Discord" src="https://img.shields.io/badge/Discord-Join%20the%20community-7289da?logo=discord&logoColor=white"></a>
+  <a href="https://github.com/tsrx-org/oxc/blob/HEAD/LICENSE"><img alt="MIT license" src="https://img.shields.io/npm/l/@tsrx/oxc"></a>
+</p>
+
+The official OXC integration for TSRX. `@tsrx/oxc` gives you three tools for
+`.tsrx` files:
+
+- a **linter**, which warns you about likely mistakes before you run your code
+- a **formatter**, which fixes spacing and punctuation so every file matches
+- a **parser**, which reads a file into a form your own tools can work with
+
+A `.tsrx` file is TypeScript with HTML-like markup in it, plus blocks like `@if`
+and `@for` for showing something only sometimes, or once per item in a list.
+[OXC](https://oxc.rs) is a set of fast tools for JavaScript and TypeScript,
+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)
+
+## Install
+
+```sh
+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).
+
+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).
+
+## Usage
+
+```sh
+npx oxlint src/Cart.tsrx        # Lint the file.
+npx oxfmt --check src/Cart.tsrx # Show what formatting would change.
+npx oxfmt --write src/Cart.tsrx # Apply it.
+```
+
+Always give these commands a path. A bare `npx oxlint` also checks
+`node_modules`, and `--fix` (the flag that lets `oxlint` edit your files) will
+rewrite files in there.
+
+Your `.js`, `.jsx`, `.ts`, and `.tsx` files go straight to OXC, exactly as they
+would without this package. Only `.tsrx` files do anything TSRX-specific.
+
+## What works today
+
+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
+outside that list **fails closed**: the command stops and says what it found and
+where, rather than guessing and maybe producing wrong output.
+
+**This package compiles nothing.** It never builds or runs your app. Turning
+`.tsrx` into something a browser can run is your framework's TSRX plugin's job,
+such as `@tsrx/vite-plugin-react`. See
+[tsrx.dev/getting-started](https://tsrx.dev/getting-started). Without one, your
+build tool reads `.tsrx` as plain TypeScript and stops at the first `@{`.
+
+## In your editor
+
+Install the official OXC extension, `oxc.oxc-vscode`. With `@tsrx/oxc` in the
+project there is nothing else to install or configure, and your editor
+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).
+
+## Using it from your own code
+
+```js
+import { parseSync } from "@tsrx/oxc/parser";
+import { defineConfig } from "@tsrx/oxc/lint";
+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.
+None of these compiles `.tsrx` either; that stays your framework's TSRX
+plugin's job.
+
+Framework compilers that currently call `@tsrx/core`'s parser can use the
+compatibility facade from the same package:
+
+```js
+import { parseModule } from "@tsrx/oxc/tsrx-core-compat";
+```
+
+It preserves TypeScript fields and supplies the source locations, directive
+keyword origins, comments, and complete scoped-CSS tree expected by
+`@tsrx/core` consumers.
+
+## Your own JavaScript lint plugins
+
+A plugin listed in `jsPlugins` runs on `.tsrx` from the `oxlint` command and
+inside your editor, but it sees a translated copy of your file rather than the
+TSRX you wrote, so each `.tsrx` file is read once more. The command and the
+editor both say when they have done that, and
+`settings.oxcTsrx.jsPluginsOnTsrx: false` turns it off.
+
+`oxc-tsrx-lint`, the standalone Rust command, has no Node.js to run a plugin in,
+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).
+
+## 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.
+
+`@tsrx/oxc` is the only package to depend on. The eight `@tsrx/oxc-*`
+packages are platform binaries in `optionalDependencies`, and you never name one
+yourself.
+
+## License
+
+[MIT](https://github.com/tsrx-org/oxc/blob/HEAD/LICENSE).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,49 @@
+# Third-party notices
+
+`oxc-tsrx` is the complete OXC-shaped TSRX parser, linter, formatter, and
+language-server host. It uses canonical OXC Rust crates from commit
+`8e0ed2ebb96137fb1611cdbd5742d5cb46037d40` of
+<https://github.com/oxc-project/oxc>. OXC is licensed under the MIT License.
+
+OXC is consumed as an exact-revision Cargo dependency. Its source is not
+copied, vendored, patched, or forked by this project. Target-native packages
+contain the complete generated Rust dependency inventory and byte-exact
+upstream legal files, and each `@oxc-tsrx/native-*` package carries the notices
+for the linked Rust/OXC binary distribution it ships.
+
+This package's npm dependencies are:
+
+- `@oxc-project/types` 0.140.0, MIT licensed and maintained by the OXC project,
+  for the parser declaration surface.
+- `oxlint` 1.74.0, which ordinary linting delegates to unchanged.
+- `oxfmt` 0.59.0, which ordinary formatting delegates to unchanged.
+- `oxlint-tsgolint` 0.24.0, for type-aware linting.
+- `tinyglobby` 0.2.17, MIT licensed, for file discovery.
+
+Those packages retain their own license and notice files when installed.
+
+The `oxc-tsrx/tsrx-core-compat` export adapts the CSS parser from `@tsrx/core`
+0.1.56, Copyright (c) 2025 Dominic Gannaway. The adapted source is licensed
+under the MIT License:
+
+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.
+
+OXC for TSRX is an independent community integration. It is not an official
+OXC project and is not affiliated with or endorsed by VoidZero Inc. or OXC's
+contributors.

package/bin/oxc-tsrx

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxc-tsrx.js';

package/bin/oxc-tsrx-fmt

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxc-tsrx-fmt.js';

package/bin/oxc-tsrx-lint

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxc-tsrx-lint.js';

package/bin/oxc-tsrx-lsp

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxc-tsrx-lsp.js';

package/bin/oxfmt

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxfmt.js';

package/bin/oxlint

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin/oxlint.js';

package/dist/bin/oxc-tsrx-fmt.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+//#region src/bin/oxc-tsrx-fmt.ts
+try {
+	const { resolveNativeCommand, runPassthrough } = await import("../runtime.js");
+	const native = resolveNativeCommand("format", process.argv.slice(2));
+	const result = await runPassthrough(native.executable, native.args);
+	process.exitCode = result.status;
+} catch (error) {
+	console.error(`oxc-tsrx-fmt: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/bin/oxc-tsrx-lint.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+//#region src/bin/oxc-tsrx-lint.ts
+try {
+	const { resolveNativeCommand, runPassthrough } = await import("../runtime.js");
+	const native = resolveNativeCommand("lint", process.argv.slice(2));
+	const result = await runPassthrough(native.executable, native.args);
+	process.exitCode = result.status;
+} catch (error) {
+	console.error(`oxc-tsrx-lint: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/bin/oxc-tsrx-lsp.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+//#region src/bin/oxc-tsrx-lsp.ts
+try {
+	const { resolveNativeCommand, runPassthrough } = await import("../runtime.js");
+	const native = resolveNativeCommand("server", process.argv.slice(2));
+	const result = await runPassthrough(native.executable, native.args);
+	process.exitCode = result.status;
+} catch (error) {
+	console.error(`oxc-tsrx-lsp: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/bin/oxc-tsrx.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+//#region src/bin/oxc-tsrx.ts
+function usage() {
+	return `oxc-tsrx
+
+Usage:
+  oxc-tsrx providers [--project <directory>] [--json]
+  oxc-tsrx setup [--project <directory>] [--dry-run] [--write-tsconfig]
+                 [--workspace-root <directory>] [--json]
+  oxc-tsrx status [--project <directory>] [--json]
+  oxc-tsrx remove [--project <directory>] [--dry-run] [--json]
+
+providers reports the OXC language providers the project root's direct
+dependencies declare through their static oxc.provider metadata. It reads
+package manifests only: it writes nothing, mutates no node_modules directory,
+and imports, requires, or spawns no dependency. It exits non-zero when a
+provider claims a reserved extension or when two providers collide.
+
+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.
+
+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
+finds that tool and serves no .tsrx diagnostics, so setup merges the single key
+"oxc.path.oxlint" into your .vscode/settings.json. Everything else in that file
+is preserved, an existing "oxc.path.oxlint" is reported rather than overwritten,
+and remove takes back only that key. It never edits package.json, and it never
+edits tsconfig.json unless you ask.
+
+VS Code reads .vscode/settings.json only from the folder you open as the
+workspace root, never from a subfolder of it, and setup writes at your project
+root, meaning the nearest package.json. In a monorepo those are different
+folders, so setup and status name every folder above your project root that
+looks like a workspace root, and the file that made each one look like one,
+rather than quietly writing a key nothing reads.
+
+--workspace-root <directory> is the only way to write above your project root,
+and it is never implied. The value is written relative to the folder you name.
+Note that a multi-root window resolves a relative "oxc.path.oxlint" against its
+first folder, not against the folder holding the settings file.
+
+setup also reports the TSRX editor prerequisites it deliberately does not own:
+@tsrx/typescript-plugin, a framework binding, the tsconfig.json plugins entry,
+and a TypeScript version the plugin supports. It installs none of them.
+
+--write-tsconfig is the one exception, and it is opt-in for that reason. It adds
+"plugins": [{ "name": "@tsrx/typescript-plugin" }] under compilerOptions in the
+tsconfig that owns your source, keeping every comment and every other byte in
+the file. A solution-style root is skipped in favour of the referenced project
+that includes your source, and an existing "plugins" list is reported rather
+than appended to. Without the flag, setup only tells you the entry is missing.
+`;
+}
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+const VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-V"]);
+function parseArguments(argv) {
+	const [first = "help", ...rest] = argv;
+	const options = {
+		command: HELP_FLAGS.has(first) ? "help" : VERSION_FLAGS.has(first) ? "version" : first,
+		projectRoot: void 0,
+		dryRun: false,
+		json: false
+	};
+	for (let index = 0; index < rest.length; index += 1) {
+		const argument = rest[index];
+		if (argument === "--project") {
+			options.projectRoot = rest[++index];
+			if (!options.projectRoot) throw new Error("--project requires a directory");
+		} else if (argument.startsWith("--project=")) options.projectRoot = argument.slice(10);
+		else if (argument === "--dry-run") options.dryRun = true;
+		else if (argument === "--write-tsconfig") options.writeTsconfig = true;
+		else if (argument === "--workspace-root") {
+			options.workspaceRoot = rest[++index];
+			if (!options.workspaceRoot) throw new Error("--workspace-root requires a directory");
+		} else if (argument.startsWith("--workspace-root=")) {
+			options.workspaceRoot = argument.slice(17);
+			if (!options.workspaceRoot) throw new Error("--workspace-root requires a directory");
+		} else if (argument === "--json") options.json = true;
+		else if (HELP_FLAGS.has(argument)) options.command = "help";
+		else if (VERSION_FLAGS.has(argument)) options.command = "version";
+		else throw new Error(`unknown option: ${argument}`);
+	}
+	return options;
+}
+function printResult(result, json, format) {
+	process.stdout.write(json ? `${JSON.stringify(result, null, 2)}\n` : format(result));
+}
+try {
+	const options = parseArguments(process.argv.slice(2));
+	if (options.command === "help") process.stdout.write(usage());
+	else if (options.command === "version") {
+		const { createRequire } = await import("node:module");
+		const manifest = createRequire(import.meta.url)("../../package.json");
+		process.stdout.write(`oxc-tsrx ${manifest.version}\n`);
+	} else if (options.command === "providers") {
+		const { collectProviderReport, formatProviderReport } = await import("../providers-report.js");
+		const report = await collectProviderReport(options);
+		process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : formatProviderReport(report));
+		if (!report.ok) process.exitCode = 1;
+	} else {
+		const { compatibilityStatus, formatCompatibilityReport, removeCompatibility, setupCompatibility } = await import("../compat.js");
+		if (options.command === "setup" || options.command === "activate") printResult(await setupCompatibility(options), options.json, formatCompatibilityReport);
+		else if (options.command === "status") printResult(await compatibilityStatus(options), options.json, formatCompatibilityReport);
+		else if (options.command === "remove" || options.command === "deactivate") printResult(await removeCompatibility(options), options.json, formatCompatibilityReport);
+		else throw new Error(`unknown command: ${options.command}\n\n${usage()}`);
+	}
+} catch (error) {
+	console.error(`oxc-tsrx: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/bin/oxfmt.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+//#region src/bin/oxfmt.ts
+try {
+	const { decideCanonicalCommand, deferralNotice, runOfficialCommand } = await import("../canonical-command.js");
+	const args = process.argv.slice(2);
+	const decision = await decideCanonicalCommand("oxfmt");
+	if (decision.owner === "project") {
+		const notice = deferralNotice(decision, args);
+		if (notice !== null) console.error(notice);
+		await runOfficialCommand(decision);
+	} else {
+		const { canRunCanonicalOxfmt, importDeclaredPackageBinary } = await import("../format-invocation.js");
+		if (canRunCanonicalOxfmt(args)) await importDeclaredPackageBinary("oxfmt-current", "oxfmt", import.meta.url);
+		else {
+			const { runCli } = await import("../format-cli.js");
+			process.exitCode = await runCli(args);
+		}
+	}
+} catch (error) {
+	console.error(`oxfmt (oxc-tsrx): ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/bin/oxlint.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+//#region src/bin/oxlint.ts
+try {
+	const { enableCompileCache } = await import("node:module");
+	enableCompileCache?.();
+} catch {}
+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") {
+		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);
+		else {
+			const plan = Boolean(process.env.VP_VERSION || process.env.VP_COMMAND || process.env.NODE_PACKAGE_MANAGER === "vite-plus") ? null : planCanonicalOxlintComposition(args);
+			const prestart = plan === null ? Promise.resolve(null) : import("../lint-prestart.js").then(({ startCanonicalOxlint }) => startCanonicalOxlint(plan.args));
+			const [{ runCli }, prestartedUpstream] = await Promise.all([import("../lint-cli.js"), prestart]);
+			process.exitCode = await runCli(args, { prestartedUpstream });
+		}
+	}
+} catch (error) {
+	console.error(`oxlint (oxc-tsrx): ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/canonical-command.d.ts

@@ -0,0 +1,50 @@
+export type OxcTsrxCanonicalCommand = "oxlint" | "oxfmt";
+
+export interface OxcTsrxCanonicalDecisionKept {
+  readonly command: OxcTsrxCanonicalCommand;
+  readonly owner: "@tsrx/oxc";
+  readonly reason: "no-project-manifest" | "not-directly-declared" | "compatibility-facade";
+  readonly projectRoot: string | null;
+  readonly officialRoot?: string;
+}
+
+export interface OxcTsrxCanonicalDecisionDeferred {
+  readonly command: OxcTsrxCanonicalCommand;
+  readonly owner: "project";
+  readonly reason: string;
+  readonly projectRoot: string;
+  readonly officialRoot: string;
+  readonly officialVersion: string | null;
+  readonly binPath: string;
+}
+
+export type OxcTsrxCanonicalDecision =
+  | OxcTsrxCanonicalDecisionKept
+  | OxcTsrxCanonicalDecisionDeferred;
+
+export interface OxcTsrxCanonicalOptions {
+  readonly cwd?: string;
+}
+
+export declare function decideCanonicalCommand(
+  command: OxcTsrxCanonicalCommand,
+  options?: OxcTsrxCanonicalOptions,
+): Promise<OxcTsrxCanonicalDecision>;
+
+export declare function providedArguments(args: readonly string[]): string[];
+
+export declare function usesNodeInterpreter(path: string): Promise<boolean>;
+
+export declare function deferralNotice(
+  decision: OxcTsrxCanonicalDecision,
+  args: readonly string[],
+): string | null;
+
+export interface OxcTsrxRunOfficialOptions {
+  readonly spawn?: typeof import("node:child_process").spawn;
+}
+
+export declare function runOfficialCommand(
+  decision: OxcTsrxCanonicalDecisionDeferred,
+  options?: OxcTsrxRunOfficialOptions,
+): Promise<void>;