@unthrown/oxlint 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit Travers
+
+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,53 @@
+# @unthrown/oxlint
+
+> An [oxlint](https://oxc.rs/docs/guide/usage/linter) plugin that enforces
+> [unthrown](https://github.com/btravstack/unthrown)'s conventions.
+
+📖 **[Documentation](https://btravstack.github.io/unthrown/guide/linting)**
+
+```sh
+pnpm add -D @unthrown/oxlint oxlint
+```
+
+A small set of lint rules that keep unthrown code honest — turning two of the
+library's theses into automated checks.
+
+## Rules
+
+| Rule                               | What it enforces                                                                                                                                                                                                                                                                                   |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `unthrown/no-ambiguous-error-type` | The `E` in `Result<T, E>` / `AsyncResult<T, E>` must name a concrete domain error — no `unknown`, `any`, `Error`, `object`, bare `{}`, or primitives. (`never` is allowed.) This is [Thesis #1](https://btravstack.github.io/unthrown/guide/why-unthrown): `E` is only the _anticipated_ failures. |
+| `unthrown/prefer-async-result`     | Prefer `AsyncResult<T, E>` over `Promise<Result<T, E>>` — a raw `Promise<Result>` can still reject. Autofixable.                                                                                                                                                                                   |
+
+Both rules resolve the import source via scope analysis, so they only fire on
+unthrown's own `Result` / `AsyncResult` — a `Result` from another library is left
+alone.
+
+## Usage
+
+Register the plugin and enable its rules in your `.oxlintrc.json`:
+
+```json
+{
+  "jsPlugins": [{ "name": "unthrown", "specifier": "@unthrown/oxlint" }],
+  "rules": {
+    "unthrown/no-ambiguous-error-type": "error",
+    "unthrown/prefer-async-result": "error"
+  }
+}
+```
+
+The package's default export also exposes a `recommended` preset (an oxlint
+config that registers the plugin and turns both rules on) for setups that build
+their config programmatically:
+
+```ts
+import unthrown from "@unthrown/oxlint";
+// unthrown.recommended → { jsPlugins: [...], rules: { "unthrown/...": "error" } }
+```
+
+`oxlint` is a peer dependency. JS plugins require a recent oxlint (≥ 1.69).
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,176 @@
+let _oxlint_plugins = require("@oxlint/plugins");
+let oxlint = require("oxlint");
+//#region src/helpers/get-import-source.ts
+/**
+* Resolve the module a given identifier was imported from, via scope analysis —
+* e.g. the `Result` in `Result<T, E>` resolves to `"unthrown"` when it was
+* `import type { Result } from "unthrown"`. Returns `undefined` if it cannot be
+* resolved to an import (so callers stay conservative — no false positives).
+*/
+const getImportSource = (scope, target) => {
+	const node = (scope.references.find((ref) => ref.identifier === target)?.resolved)?.defs[0]?.parent;
+	if (node?.type !== "ImportDeclaration") return void 0;
+	return node.source.value;
+};
+//#endregion
+//#region src/helpers/has-type-arguments.ts
+/**
+* Narrow a node to one carrying exactly `count` type arguments
+* (`node.typeArguments.params` of that length).
+*/
+const hasTypeArguments = (node, count) => {
+	return "typeArguments" in node && node.typeArguments != null && node.typeArguments.params.length === count;
+};
+//#endregion
+//#region src/helpers/is-identifier-type-name.ts
+/**
+* Narrow a `TSTypeReference` to one whose `typeName` is a bare `Identifier`,
+* optionally one of `names`. unthrown's `Result` / `AsyncResult` are used as
+* bare identifiers (not namespaced), so this is how we spot them.
+*/
+const isIdentifierTypeName = (node, names) => {
+	return node.typeName.type === "Identifier" && (!names || names.includes(node.typeName.name));
+};
+//#endregion
+//#region src/rules/no-ambiguous-error-type.ts
+const MODULE$1 = "unthrown";
+const RESULT_TYPES = ["Result", "AsyncResult"];
+const AMBIGUOUS_KEYWORDS = /* @__PURE__ */ new Set([
+	"TSUnknownKeyword",
+	"TSAnyKeyword",
+	"TSStringKeyword",
+	"TSNumberKeyword",
+	"TSBooleanKeyword",
+	"TSBigIntKeyword",
+	"TSSymbolKeyword",
+	"TSObjectKeyword",
+	"TSNullKeyword",
+	"TSUndefinedKeyword"
+]);
+/**
+* Disallow a non-specific error type in the `E` position of `Result<T, E>` /
+* `AsyncResult<T, E>`: `unknown`, `any`, `Error`, bare `{}` / `object`, and the
+* primitive keywords. `E` should name the *anticipated* domain failures — a
+* tagged error, a union of them, a literal — not "anything went wrong". `never`
+* (an intentionally error-free result) is allowed.
+*/
+const noAmbiguousErrorType = (0, _oxlint_plugins.defineRule)({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow non-specific error types (`unknown`, `any`, `Error`, `object`, `{}`, primitives) in the error position of `Result` / `AsyncResult`",
+			recommended: true
+		},
+		messages: { noAmbiguousErrorType: "Specify a concrete domain error instead of `{{ type }}` in `{{ result }}`." }
+	},
+	createOnce: (context) => {
+		return { TSTypeReference: (node) => {
+			if (!isIdentifierTypeName(node, RESULT_TYPES)) return;
+			if (!hasTypeArguments(node, 2)) return;
+			if (getImportSource(context.sourceCode.getScope(node), node.typeName) !== MODULE$1) return;
+			const errorNode = node.typeArguments.params[1];
+			if (!isAmbiguousType(errorNode)) return;
+			context.report({
+				node: errorNode,
+				messageId: "noAmbiguousErrorType",
+				data: {
+					type: context.sourceCode.getText(errorNode),
+					result: context.sourceCode.getText(node)
+				}
+			});
+		} };
+	}
+});
+/**
+* Whether an error-position type is non-specific. Recurses into unions and
+* intersections, so `MyError | unknown` and `Error | MyError` are flagged too —
+* one ambiguous member taints the whole type.
+*/
+function isAmbiguousType(node) {
+	if (node.type === "TSUnionType" || node.type === "TSIntersectionType") return node.types.some(isAmbiguousType);
+	if (node.type === "TSTypeLiteral") return node.members.length === 0;
+	if (node.type === "TSTypeReference") return node.typeName.type === "Identifier" && node.typeName.name === "Error";
+	return AMBIGUOUS_KEYWORDS.has(node.type);
+}
+//#endregion
+//#region src/helpers/has-named-import.ts
+/**
+* Whether `name` is in scope as a named import from `module` (e.g. is
+* `AsyncResult` imported from `"unthrown"`). Used to decide whether an autofix
+* can safely reference it. Walks up the scope chain.
+*/
+const hasNamedImport = (scope, name, module) => {
+	for (let current = scope; current; current = current.upper) {
+		const variable = current.variables.find((v) => v.name === name);
+		if (variable) {
+			const parent = variable.defs[0]?.parent;
+			return parent?.type === "ImportDeclaration" && parent.source.value === module;
+		}
+	}
+	return false;
+};
+//#endregion
+//#region src/rules/prefer-async-result.ts
+const MODULE = "unthrown";
+/**
+* Prefer unthrown's `AsyncResult<T, E>` over `Promise<Result<T, E>>`. A raw
+* `Promise<Result>` can *reject*, reintroducing the throw channel `AsyncResult`
+* is designed to eliminate — so the wrapper is both shorter and stronger.
+*
+* Autofixable — but the fix is only offered when `AsyncResult` is already
+* imported from `unthrown`, so it can't rewrite to an undefined name.
+*/
+const preferAsyncResult = (0, _oxlint_plugins.defineRule)({
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer `AsyncResult<T, E>` over `Promise<Result<T, E>>`",
+			recommended: true
+		},
+		messages: { preferAsyncResult: "Use `AsyncResult<T, E>` instead of `Promise<Result<T, E>>`." },
+		fixable: "code"
+	},
+	createOnce: (context) => {
+		return { TSTypeReference: (node) => {
+			if (!isIdentifierTypeName(node, ["Promise"])) return;
+			if (!hasTypeArguments(node, 1)) return;
+			const inner = node.typeArguments.params[0];
+			if (inner.type !== "TSTypeReference") return;
+			if (!isIdentifierTypeName(inner, ["Result"])) return;
+			if (!hasTypeArguments(inner, 2)) return;
+			const scope = context.sourceCode.getScope(node);
+			if (getImportSource(scope, inner.typeName) !== MODULE) return;
+			const canFix = hasNamedImport(scope, "AsyncResult", MODULE);
+			context.report({
+				node,
+				messageId: "preferAsyncResult",
+				...canFix && { fix: (fixer) => {
+					const value = context.sourceCode.getText(inner.typeArguments.params[0]);
+					const error = context.sourceCode.getText(inner.typeArguments.params[1]);
+					return fixer.replaceText(node, `AsyncResult<${value}, ${error}>`);
+				} }
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/index.ts
+const plugin = (0, _oxlint_plugins.eslintCompatPlugin)({
+	meta: { name: "unthrown" },
+	rules: {
+		"no-ambiguous-error-type": noAmbiguousErrorType,
+		"prefer-async-result": preferAsyncResult
+	}
+});
+plugin.recommended = (0, oxlint.defineConfig)({
+	jsPlugins: [{
+		name: "unthrown",
+		specifier: "@unthrown/oxlint"
+	}],
+	rules: {
+		"unthrown/no-ambiguous-error-type": "error",
+		"unthrown/prefer-async-result": "error"
+	}
+});
+//#endregion
+module.exports = plugin;

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+import { Plugin } from "@oxlint/plugins";
+import { OxlintConfig } from "oxlint";
+
+//#region src/index.d.ts
+type UnthrownPlugin = Plugin & {
+  recommended: OxlintConfig;
+};
+declare const plugin: UnthrownPlugin;
+export = plugin;
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;KAmBK,cAAA,GAAiB,MAAA;EAAW,WAAA,EAAa,YAAY;AAAA;AAAA,cAEpD,MAAA,EAMA,cAAc;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { Plugin } from "@oxlint/plugins";
+import { OxlintConfig } from "oxlint";
+
+//#region src/index.d.ts
+type UnthrownPlugin = Plugin & {
+  recommended: OxlintConfig;
+};
+declare const plugin: UnthrownPlugin;
+//#endregion
+export { plugin as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;KAmBK,cAAA,GAAiB,MAAA;EAAW,WAAA,EAAa,YAAY;AAAA;AAAA,cAEpD,MAAA,EAMA,cAAc"}

package/dist/index.mjs

@@ -0,0 +1,169 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+import { defineConfig } from "oxlint";
+//#region src/helpers/get-import-source.ts
+/**
+* Resolve the module a given identifier was imported from, via scope analysis —
+* e.g. the `Result` in `Result<T, E>` resolves to `"unthrown"` when it was
+* `import type { Result } from "unthrown"`. Returns `undefined` if it cannot be
+* resolved to an import (so callers stay conservative — no false positives).
+*/
+const getImportSource = (scope, target) => {
+	const node = (scope.references.find((ref) => ref.identifier === target)?.resolved)?.defs[0]?.parent;
+	if (node?.type !== "ImportDeclaration") return void 0;
+	return node.source.value;
+};
+//#endregion
+//#region src/helpers/has-type-arguments.ts
+/**
+* Narrow a node to one carrying exactly `count` type arguments
+* (`node.typeArguments.params` of that length).
+*/
+const hasTypeArguments = (node, count) => {
+	return "typeArguments" in node && node.typeArguments != null && node.typeArguments.params.length === count;
+};
+//#endregion
+//#region src/helpers/is-identifier-type-name.ts
+/**
+* Narrow a `TSTypeReference` to one whose `typeName` is a bare `Identifier`,
+* optionally one of `names`. unthrown's `Result` / `AsyncResult` are used as
+* bare identifiers (not namespaced), so this is how we spot them.
+*/
+const isIdentifierTypeName = (node, names) => {
+	return node.typeName.type === "Identifier" && (!names || names.includes(node.typeName.name));
+};
+//#endregion
+//#region src/rules/no-ambiguous-error-type.ts
+const MODULE$1 = "unthrown";
+const RESULT_TYPES = ["Result", "AsyncResult"];
+const AMBIGUOUS_KEYWORDS = /* @__PURE__ */ new Set([
+	"TSUnknownKeyword",
+	"TSAnyKeyword",
+	"TSStringKeyword",
+	"TSNumberKeyword",
+	"TSBooleanKeyword",
+	"TSBigIntKeyword",
+	"TSSymbolKeyword",
+	"TSObjectKeyword",
+	"TSNullKeyword",
+	"TSUndefinedKeyword"
+]);
+/**
+* Disallow a non-specific error type in the `E` position of `Result<T, E>` /
+* `AsyncResult<T, E>`: `unknown`, `any`, `Error`, bare `{}` / `object`, and the
+* primitive keywords. `E` should name the *anticipated* domain failures — a
+* tagged error, a union of them, a literal — not "anything went wrong". `never`
+* (an intentionally error-free result) is allowed.
+*/
+const noAmbiguousErrorType = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow non-specific error types (`unknown`, `any`, `Error`, `object`, `{}`, primitives) in the error position of `Result` / `AsyncResult`",
+			recommended: true
+		},
+		messages: { noAmbiguousErrorType: "Specify a concrete domain error instead of `{{ type }}` in `{{ result }}`." }
+	},
+	createOnce: (context) => {
+		return { TSTypeReference: (node) => {
+			if (!isIdentifierTypeName(node, RESULT_TYPES)) return;
+			if (!hasTypeArguments(node, 2)) return;
+			if (getImportSource(context.sourceCode.getScope(node), node.typeName) !== MODULE$1) return;
+			const errorNode = node.typeArguments.params[1];
+			if (!isAmbiguousType(errorNode)) return;
+			context.report({
+				node: errorNode,
+				messageId: "noAmbiguousErrorType",
+				data: {
+					type: context.sourceCode.getText(errorNode),
+					result: context.sourceCode.getText(node)
+				}
+			});
+		} };
+	}
+});
+/**
+* Whether an error-position type is non-specific. Recurses into unions and
+* intersections, so `MyError | unknown` and `Error | MyError` are flagged too —
+* one ambiguous member taints the whole type.
+*/
+function isAmbiguousType(node) {
+	if (node.type === "TSUnionType" || node.type === "TSIntersectionType") return node.types.some(isAmbiguousType);
+	if (node.type === "TSTypeLiteral") return node.members.length === 0;
+	if (node.type === "TSTypeReference") return node.typeName.type === "Identifier" && node.typeName.name === "Error";
+	return AMBIGUOUS_KEYWORDS.has(node.type);
+}
+//#endregion
+//#region src/helpers/has-named-import.ts
+/**
+* Whether `name` is in scope as a named import from `module` (e.g. is
+* `AsyncResult` imported from `"unthrown"`). Used to decide whether an autofix
+* can safely reference it. Walks up the scope chain.
+*/
+const hasNamedImport = (scope, name, module) => {
+	for (let current = scope; current; current = current.upper) {
+		const variable = current.variables.find((v) => v.name === name);
+		if (variable) {
+			const parent = variable.defs[0]?.parent;
+			return parent?.type === "ImportDeclaration" && parent.source.value === module;
+		}
+	}
+	return false;
+};
+//#endregion
+//#region src/rules/prefer-async-result.ts
+const MODULE = "unthrown";
+//#endregion
+//#region src/index.ts
+const plugin = eslintCompatPlugin({
+	meta: { name: "unthrown" },
+	rules: {
+		"no-ambiguous-error-type": noAmbiguousErrorType,
+		"prefer-async-result": defineRule({
+			meta: {
+				type: "suggestion",
+				docs: {
+					description: "Prefer `AsyncResult<T, E>` over `Promise<Result<T, E>>`",
+					recommended: true
+				},
+				messages: { preferAsyncResult: "Use `AsyncResult<T, E>` instead of `Promise<Result<T, E>>`." },
+				fixable: "code"
+			},
+			createOnce: (context) => {
+				return { TSTypeReference: (node) => {
+					if (!isIdentifierTypeName(node, ["Promise"])) return;
+					if (!hasTypeArguments(node, 1)) return;
+					const inner = node.typeArguments.params[0];
+					if (inner.type !== "TSTypeReference") return;
+					if (!isIdentifierTypeName(inner, ["Result"])) return;
+					if (!hasTypeArguments(inner, 2)) return;
+					const scope = context.sourceCode.getScope(node);
+					if (getImportSource(scope, inner.typeName) !== MODULE) return;
+					const canFix = hasNamedImport(scope, "AsyncResult", MODULE);
+					context.report({
+						node,
+						messageId: "preferAsyncResult",
+						...canFix && { fix: (fixer) => {
+							const value = context.sourceCode.getText(inner.typeArguments.params[0]);
+							const error = context.sourceCode.getText(inner.typeArguments.params[1]);
+							return fixer.replaceText(node, `AsyncResult<${value}, ${error}>`);
+						} }
+					});
+				} };
+			}
+		})
+	}
+});
+plugin.recommended = defineConfig({
+	jsPlugins: [{
+		name: "unthrown",
+		specifier: "@unthrown/oxlint"
+	}],
+	rules: {
+		"unthrown/no-ambiguous-error-type": "error",
+		"unthrown/prefer-async-result": "error"
+	}
+});
+//#endregion
+export { plugin as default };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["MODULE"],"sources":["../src/helpers/get-import-source.ts","../src/helpers/has-type-arguments.ts","../src/helpers/is-identifier-type-name.ts","../src/rules/no-ambiguous-error-type.ts","../src/helpers/has-named-import.ts","../src/rules/prefer-async-result.ts","../src/index.ts"],"sourcesContent":["import type { ESTree, Scope } from \"@oxlint/plugins\";\n\n/**\n * Resolve the module a given identifier was imported from, via scope analysis —\n * e.g. the `Result` in `Result<T, E>` resolves to `\"unthrown\"` when it was\n * `import type { Result } from \"unthrown\"`. Returns `undefined` if it cannot be\n * resolved to an import (so callers stay conservative — no false positives).\n */\nexport const getImportSource = (scope: Scope, target: ESTree.Node): string | undefined => {\n  const variable = scope.references.find((ref) => ref.identifier === target)?.resolved;\n  const node = variable?.defs[0]?.parent;\n  if (node?.type !== \"ImportDeclaration\") return undefined;\n  return node.source.value;\n};\n","import type { ESTree } from \"@oxlint/plugins\";\n\ntype Tuple<T, N extends number, R extends T[] = []> = R[\"length\"] extends N\n  ? R\n  : Tuple<T, N, [...R, T]>;\n\n/**\n * Narrow a node to one carrying exactly `count` type arguments\n * (`node.typeArguments.params` of that length).\n */\nexport const hasTypeArguments = <N extends number>(\n  node: ESTree.Node,\n  count: N,\n): node is ESTree.Node & { typeArguments: { params: Tuple<ESTree.TSType, N> } } => {\n  return (\n    \"typeArguments\" in node &&\n    node.typeArguments != null &&\n    node.typeArguments.params.length === count\n  );\n};\n","import type { ESTree } from \"@oxlint/plugins\";\n\n/**\n * Narrow a `TSTypeReference` to one whose `typeName` is a bare `Identifier`,\n * optionally one of `names`. unthrown's `Result` / `AsyncResult` are used as\n * bare identifiers (not namespaced), so this is how we spot them.\n */\nexport const isIdentifierTypeName = (\n  node: ESTree.TSTypeReference,\n  names?: readonly string[],\n): node is ESTree.TSTypeReference & { typeName: ESTree.IdentifierReference } => {\n  return node.typeName.type === \"Identifier\" && (!names || names.includes(node.typeName.name));\n};\n","import { defineRule } from \"@oxlint/plugins\";\n\nimport { getImportSource } from \"../helpers/get-import-source.js\";\nimport { hasTypeArguments } from \"../helpers/has-type-arguments.js\";\nimport { isIdentifierTypeName } from \"../helpers/is-identifier-type-name.js\";\n\nimport type { ESTree } from \"@oxlint/plugins\";\n\nconst MODULE = \"unthrown\";\nconst RESULT_TYPES = [\"Result\", \"AsyncResult\"] as const;\n\n// Keyword type nodes that say nothing about the domain — they make `E` a\n// catch-all, which is exactly what Thesis #1 forbids.\nconst AMBIGUOUS_KEYWORDS: ReadonlySet<string> = new Set([\n  \"TSUnknownKeyword\",\n  \"TSAnyKeyword\",\n  \"TSStringKeyword\",\n  \"TSNumberKeyword\",\n  \"TSBooleanKeyword\",\n  \"TSBigIntKeyword\",\n  \"TSSymbolKeyword\",\n  \"TSObjectKeyword\",\n  \"TSNullKeyword\",\n  \"TSUndefinedKeyword\",\n]);\n\n/**\n * Disallow a non-specific error type in the `E` position of `Result<T, E>` /\n * `AsyncResult<T, E>`: `unknown`, `any`, `Error`, bare `{}` / `object`, and the\n * primitive keywords. `E` should name the *anticipated* domain failures — a\n * tagged error, a union of them, a literal — not \"anything went wrong\". `never`\n * (an intentionally error-free result) is allowed.\n */\nexport const noAmbiguousErrorType = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Disallow non-specific error types (`unknown`, `any`, `Error`, `object`, `{}`, primitives) in the error position of `Result` / `AsyncResult`\",\n      recommended: true,\n    },\n    messages: {\n      noAmbiguousErrorType:\n        \"Specify a concrete domain error instead of `{{ type }}` in `{{ result }}`.\",\n    },\n  },\n  createOnce: (context) => {\n    return {\n      TSTypeReference: (node) => {\n        if (!isIdentifierTypeName(node, RESULT_TYPES)) return;\n        if (!hasTypeArguments(node, 2)) return;\n\n        const importSource = getImportSource(context.sourceCode.getScope(node), node.typeName);\n        if (importSource !== MODULE) return;\n\n        const errorNode: ESTree.TSType = node.typeArguments.params[1];\n        if (!isAmbiguousType(errorNode)) return;\n\n        context.report({\n          node: errorNode,\n          messageId: \"noAmbiguousErrorType\",\n          data: {\n            type: context.sourceCode.getText(errorNode),\n            result: context.sourceCode.getText(node),\n          },\n        });\n      },\n    };\n  },\n});\n\n/**\n * Whether an error-position type is non-specific. Recurses into unions and\n * intersections, so `MyError | unknown` and `Error | MyError` are flagged too —\n * one ambiguous member taints the whole type.\n */\nfunction isAmbiguousType(node: ESTree.TSType): boolean {\n  if (node.type === \"TSUnionType\" || node.type === \"TSIntersectionType\") {\n    return node.types.some(isAmbiguousType);\n  }\n  // The *empty* object literal `{}` is ambiguous; `{ code: number }` is fine.\n  if (node.type === \"TSTypeLiteral\") return node.members.length === 0;\n  // The bare `Error` class is too generic; a `MyError` is fine.\n  if (node.type === \"TSTypeReference\") {\n    return node.typeName.type === \"Identifier\" && node.typeName.name === \"Error\";\n  }\n  return AMBIGUOUS_KEYWORDS.has(node.type);\n}\n","import type { Scope } from \"@oxlint/plugins\";\n\n/**\n * Whether `name` is in scope as a named import from `module` (e.g. is\n * `AsyncResult` imported from `\"unthrown\"`). Used to decide whether an autofix\n * can safely reference it. Walks up the scope chain.\n */\nexport const hasNamedImport = (scope: Scope, name: string, module: string): boolean => {\n  for (let current: Scope | null = scope; current; current = current.upper) {\n    const variable = current.variables.find((v) => v.name === name);\n    if (variable) {\n      const parent = variable.defs[0]?.parent;\n      return parent?.type === \"ImportDeclaration\" && parent.source.value === module;\n    }\n  }\n  return false;\n};\n","import { defineRule } from \"@oxlint/plugins\";\n\nimport { getImportSource } from \"../helpers/get-import-source.js\";\nimport { hasNamedImport } from \"../helpers/has-named-import.js\";\nimport { hasTypeArguments } from \"../helpers/has-type-arguments.js\";\nimport { isIdentifierTypeName } from \"../helpers/is-identifier-type-name.js\";\n\nconst MODULE = \"unthrown\";\n\n/**\n * Prefer unthrown's `AsyncResult<T, E>` over `Promise<Result<T, E>>`. A raw\n * `Promise<Result>` can *reject*, reintroducing the throw channel `AsyncResult`\n * is designed to eliminate — so the wrapper is both shorter and stronger.\n *\n * Autofixable — but the fix is only offered when `AsyncResult` is already\n * imported from `unthrown`, so it can't rewrite to an undefined name.\n */\nexport const preferAsyncResult = defineRule({\n  meta: {\n    type: \"suggestion\",\n    docs: {\n      description: \"Prefer `AsyncResult<T, E>` over `Promise<Result<T, E>>`\",\n      recommended: true,\n    },\n    messages: {\n      preferAsyncResult: \"Use `AsyncResult<T, E>` instead of `Promise<Result<T, E>>`.\",\n    },\n    fixable: \"code\",\n  },\n  createOnce: (context) => {\n    return {\n      TSTypeReference: (node) => {\n        if (!isIdentifierTypeName(node, [\"Promise\"])) return;\n        if (!hasTypeArguments(node, 1)) return;\n\n        const inner = node.typeArguments.params[0];\n        if (inner.type !== \"TSTypeReference\") return;\n        if (!isIdentifierTypeName(inner, [\"Result\"])) return;\n        if (!hasTypeArguments(inner, 2)) return;\n\n        const scope = context.sourceCode.getScope(node);\n        if (getImportSource(scope, inner.typeName) !== MODULE) return;\n\n        // Only autofix when `AsyncResult` is already importable — otherwise the\n        // rewrite would reference an undefined name. Report without a fix instead.\n        const canFix = hasNamedImport(scope, \"AsyncResult\", MODULE);\n\n        context.report({\n          node,\n          messageId: \"preferAsyncResult\",\n          ...(canFix && {\n            fix: (fixer) => {\n              const value = context.sourceCode.getText(inner.typeArguments.params[0]);\n              const error = context.sourceCode.getText(inner.typeArguments.params[1]);\n              return fixer.replaceText(node, `AsyncResult<${value}, ${error}>`);\n            },\n          }),\n        });\n      },\n    };\n  },\n});\n","// @unthrown/oxlint — an oxlint (JS) plugin that enforces unthrown's conventions\n// at lint time. Two rules:\n//\n//   unthrown/no-ambiguous-error-type  — keep `E` a concrete domain error\n//                                        (no unknown/any/Error/{}), i.e. Thesis #1.\n//   unthrown/prefer-async-result      — use AsyncResult<T,E> over Promise<Result<T,E>>.\n//\n// Enable the bundled `recommended` preset, or wire the rules by hand. See the\n// package README.\n\nimport { eslintCompatPlugin } from \"@oxlint/plugins\";\nimport { defineConfig } from \"oxlint\";\n\nimport { noAmbiguousErrorType } from \"./rules/no-ambiguous-error-type.js\";\nimport { preferAsyncResult } from \"./rules/prefer-async-result.js\";\n\nimport type { Plugin } from \"@oxlint/plugins\";\nimport type { OxlintConfig } from \"oxlint\";\n\ntype UnthrownPlugin = Plugin & { recommended: OxlintConfig };\n\nconst plugin = eslintCompatPlugin({\n  meta: { name: \"unthrown\" },\n  rules: {\n    \"no-ambiguous-error-type\": noAmbiguousErrorType,\n    \"prefer-async-result\": preferAsyncResult,\n  },\n}) as UnthrownPlugin;\n\nplugin.recommended = defineConfig({\n  jsPlugins: [{ name: \"unthrown\", specifier: \"@unthrown/oxlint\" }],\n  rules: {\n    \"unthrown/no-ambiguous-error-type\": \"error\",\n    \"unthrown/prefer-async-result\": \"error\",\n  },\n});\n\nexport default plugin;\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@unthrown/oxlint",
+  "version": "0.2.0",
+  "description": "oxlint plugin enforcing unthrown's conventions",
+  "keywords": [
+    "errors-as-values",
+    "lint",
+    "oxlint",
+    "plugin",
+    "result",
+    "typescript",
+    "unthrown"
+  ],
+  "homepage": "https://github.com/btravstack/unthrown#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/unthrown/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/unthrown.git",
+    "directory": "packages/oxlint"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.69.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "oxlint": "1.69.0",
+    "tsdown": "0.22.2",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8",
+    "@unthrown/tsconfig": "0.1.0"
+  },
+  "peerDependencies": {
+    "oxlint": "^1"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}