oxlint-plugin-effect 0.13.0 → 0.15.0

package/dist/rules/no-silent-catch-all.js

@@ -3,20 +3,24 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-silent-catch-all.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 const isEffectVoid = (node, effectNamespaces) => isStaticMember(node, effectNamespaces, "void");
 const silentlyReturnsVoid = (node, effectNamespaces) => {
-	if (node.params.length !== 0 || node.body === null) return false;
-	if (node.body.type !== "BlockStatement") return isEffectVoid(node.body, effectNamespaces);
-	if (node.body.body.length !== 1) return false;
-	const statement = node.body.body[0];
-	return statement?.type === "ReturnStatement" && statement.argument !== null && isEffectVoid(statement.argument, effectNamespaces);
+	const body = node.body;
+	if (node.params.length !== 0 || Predicate.isNull(body)) return false;
+	if (body.type !== "BlockStatement") return isEffectVoid(body, effectNamespaces);
+	if (body.body.length !== 1) return false;
+	return Option.exists(Arr.head(body.body), (statement) => statement.type === "ReturnStatement" && Predicate.isNotNull(statement.argument) && isEffectVoid(statement.argument, effectNamespaces));
 };
+/** The handler of a data-last (one argument) or data-first catch call. */
 const handlerArgument = (node) => {
-	if (node.arguments.length === 1) return node.arguments[0];
-	return node.arguments[1];
+	if (node.arguments.length === 1) return Arr.get(node.arguments, 0);
+	return Arr.get(node.arguments, 1);
 };
 const noSilentCatchAll = define({
 	name: "no-silent-catch-all",
@@ -37,12 +41,14 @@ const noSilentCatchAll = define({
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
 				if (!(isStaticMember(node.callee, namespaces, "catchAll") || isStaticMember(node.callee, namespaces, "catchAllCause"))) return Effect.void;
-				const handler = handlerArgument(node);
-				if (!isFunction(handler) || !silentlyReturnsVoid(handler, namespaces)) return Effect.void;
-				return ctx.report(make({
-					node: handler,
-					message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
-				}));
+				const silentHandler = Option.filter(Option.filter(handlerArgument(node), isFunction), (handler) => silentlyReturnsVoid(handler, namespaces));
+				return Option.match(silentHandler, {
+					onNone: () => Effect.void,
+					onSome: (handler) => ctx.report(make({
+						node: handler,
+						message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-test-globals.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-test-globals.d.ts
+declare const noTestGlobals: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noTestGlobals };

package/dist/rules/no-test-globals.js

@@ -0,0 +1,147 @@
+import { memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import { findVariableUp, getReferences, throughReferences, variables } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import { isTestFile, skipFile } from "./_test-files.js";
+import { collectTestBindings, resolveTestBinding } from "./_test-apis.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-test-globals.ts
+const globalRoots = new Set([
+	"global",
+	"globalThis",
+	"self",
+	"window"
+]);
+const mutatingCalls = new Map([["Object", new Set([
+	"assign",
+	"defineProperties",
+	"defineProperty"
+])], ["Reflect", new Set([
+	"defineProperty",
+	"deleteProperty",
+	"set"
+])]]);
+const stubbingMethods = new Set([
+	"replaceProperty",
+	"stubEnv",
+	"stubGlobal",
+	"unstubAllEnvs",
+	"unstubAllGlobals"
+]);
+const runnerGlobals = new Set([
+	"afterAll",
+	"afterEach",
+	"beforeAll",
+	"beforeEach",
+	"describe",
+	"expect",
+	"fdescribe",
+	"fit",
+	"it",
+	"jest",
+	"mock",
+	"spyOn",
+	"test",
+	"vi",
+	"xdescribe",
+	"xit",
+	"xtest"
+]);
+const capabilityHint = "Provide the capability through an Effect service or runtime input.";
+const innermostMember = (node) => {
+	if (node.object.type === "MemberExpression") return innermostMember(node.object);
+	return node;
+};
+const isStaticProperty = (node, name) => !node.computed && node.property.type === "Identifier" && node.property.name === name;
+/**
+* References to runner names that no import or declaration provides: unresolved
+* references, plus references to globals the linter configuration declares.
+*/
+const runnerGlobalReferences = (globalScope) => {
+	const ambient = variables(globalScope).filter((variable) => variable.defs.length === 0).flatMap((variable) => getReferences(variable));
+	return [...new Map([...throughReferences(globalScope), ...ambient].map((reference) => [reference.identifier, reference])).values()].filter((reference) => runnerGlobals.has(reference.identifier.name));
+};
+const noTestGlobals = define({
+	name: "no-test-globals",
+	meta: meta({
+		type: "problem",
+		description: "Keep tests off shared global state and implicit test globals."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFile(ctx.filename)) return skipFile;
+		const bindings = /* @__PURE__ */ new Map();
+		const isUnshadowedGlobal = (node, name) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), name), {
+			onNone: () => true,
+			onSome: (variable) => variable.defs.length === 0
+		});
+		const isGlobalRoot = (node) => node.type === "Identifier" && globalRoots.has(node.name) && isUnshadowedGlobal(node, node.name);
+		/** A global object, a member chain rooted at one, or a chain rooted at `process.env`. */
+		const isGlobalState = (node) => {
+			if (node.type !== "MemberExpression") return isGlobalRoot(node);
+			const innermost = innermostMember(node);
+			if (isGlobalRoot(innermost.object)) return true;
+			return innermost.object.type === "Identifier" && innermost.object.name === "process" && isStaticProperty(innermost, "env") && isUnshadowedGlobal(innermost, "process");
+		};
+		const reportWrite = (target) => {
+			if (target.type !== "MemberExpression" || !isGlobalState(target)) return Effect.void;
+			return ctx.report(make({
+				node: target,
+				message: `Avoid writing ${ctx.sourceCode.getText(target)} in tests. ${capabilityHint}`
+			}));
+		};
+		const mutatedGlobal = (call) => {
+			if (call.callee.type !== "MemberExpression") return Option.none();
+			const target = Option.filter(Option.fromUndefinedOr(call.arguments[0]), (argument) => argument.type !== "SpreadElement" && isGlobalState(argument));
+			if (Option.isNone(target)) return Option.none();
+			return Option.map(Option.filter(memberNames(call.callee), ([object, method]) => Option.exists(Option.fromUndefinedOr(mutatingCalls.get(object)), (methods) => methods.has(method)) && isUnshadowedGlobal(call, object)), ([object, method]) => `${object}.${method}() on ${ctx.sourceCode.getText(target.value)}`);
+		};
+		const stubbingCall = (call) => {
+			if (call.callee.type !== "MemberExpression") return Option.none();
+			const scope = ctx.sourceCode.getScope(call);
+			return Option.flatMap(Option.filter(memberNames(call.callee), ([, method]) => stubbingMethods.has(method)), ([object, method]) => Option.map(Option.filter(resolveTestBinding(scope, object, bindings), (binding) => binding === "jest" || binding === "vi"), (binding) => `${binding}.${method}()`));
+		};
+		const reportCall = (call) => Option.match(Option.orElse(mutatedGlobal(call), () => stubbingCall(call)), {
+			onNone: () => Effect.void,
+			onSome: (used) => ctx.report(make({
+				node: call,
+				message: `Avoid ${used} in tests. ${capabilityHint}`
+			}))
+		});
+		const reportRunnerGlobal = (reference) => ctx.report(make({
+			node: reference.identifier,
+			message: `Import ${reference.identifier.name} from your test library instead of using the runner global.`
+		}));
+		return {
+			ImportDeclaration: (node) => {
+				collectTestBindings(node, bindings);
+				return Effect.void;
+			},
+			AssignmentExpression: (node) => Option.match(narrow(node, "AssignmentExpression"), {
+				onNone: () => Effect.void,
+				onSome: (assignment) => reportWrite(assignment.left)
+			}),
+			UpdateExpression: (node) => Option.match(narrow(node, "UpdateExpression"), {
+				onNone: () => Effect.void,
+				onSome: (update) => reportWrite(update.argument)
+			}),
+			UnaryExpression: (node) => Option.match(Option.filter(narrow(node, "UnaryExpression"), (unary) => unary.operator === "delete"), {
+				onNone: () => Effect.void,
+				onSome: (unary) => reportWrite(unary.argument)
+			}),
+			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+				onNone: () => Effect.void,
+				onSome: reportCall
+			}),
+			"Program:exit": () => Option.match(Option.fromNullishOr(ctx.sourceCode.scopeManager.globalScope), {
+				onNone: () => Effect.void,
+				onSome: (globalScope) => Effect.forEach(runnerGlobalReferences(globalScope), reportRunnerGlobal, { discard: true })
+			})
+		};
+	}
+});
+//#endregion
+export { noTestGlobals };

package/dist/rules/no-test-lifecycle-hooks.js

@@ -6,6 +6,7 @@ import "../vendor/effect-oxlint/index.js";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-test-lifecycle-hooks.ts
+/** Ban test lifecycle hooks in favor of Effect scopes and scoped test variants. */
 const lifecycleHooks = new Set([
 	"afterAll",
 	"afterEach",
@@ -23,8 +24,9 @@ const noTestLifecycleHooks = define({
 		return { CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
 			onNone: () => Effect.void,
 			onSome: (call) => {
-				const name = Option.getOrUndefined(calleeName(call));
-				if (name === void 0 || !lifecycleHooks.has(name)) return Effect.void;
+				const hook = Option.filter(calleeName(call), (name) => lifecycleHooks.has(name));
+				if (Option.isNone(hook)) return Effect.void;
+				const name = hook.value;
 				return ctx.report(make({
 					node: call,
 					message: `Avoid ${name}(). Use effect-bun-test scoped tests and Effect.acquireRelease for fixture lifecycles.`

package/dist/rules/no-unbounded-concurrency.js

@@ -2,18 +2,24 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unbounded-concurrency.ts
+/** The first `concurrency: "unbounded"` value in an options object literal. */
 const unboundedConcurrency = (node) => {
-	if (node?.type !== "ObjectExpression") return void 0;
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (!(property.key.type === "Identifier" && property.key.name === "concurrency" || property.key.type === "Literal" && property.key.value === "concurrency")) continue;
-		if (property.value.type === "Literal" && property.value.value === "unbounded") return property.value;
-	}
+	if (node.type !== "ObjectExpression") return Option.none();
+	return Option.map(Arr.findFirst(staticProperties(node, "concurrency"), (property) => property.value.type === "Literal" && property.value.value === "unbounded"), (property) => property.value);
+};
+const fixedCollection = (node) => node.type === "ArrayExpression" || node.type === "ObjectExpression";
+/** Where `Effect.all` and `Effect.forEach` take their options. */
+const optionsIndex = (callee, effectNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "forEach")) return Option.some(2);
+	if (isStaticMember(callee, effectNamespaces, "all")) return Option.some(1);
+	return Option.none();
 };
-const fixedCollection = (node) => node?.type === "ArrayExpression" || node?.type === "ObjectExpression";
 const noUnboundedConcurrency = define({
 	name: "no-unbounded-concurrency",
 	meta: meta({
@@ -32,16 +38,15 @@ const noUnboundedConcurrency = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
-				let optionsIndex;
-				if (isStaticMember(node.callee, namespaces, "all")) optionsIndex = 1;
-				if (isStaticMember(node.callee, namespaces, "forEach")) optionsIndex = 2;
-				if (optionsIndex === void 0 || fixedCollection(node.arguments[0])) return Effect.void;
-				const unbounded = unboundedConcurrency(node.arguments[optionsIndex]);
-				if (unbounded === void 0) return Effect.void;
-				return ctx.report(make({
-					node: unbounded,
-					message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
-				}));
+				if (Option.exists(Arr.head(node.arguments), fixedCollection)) return Effect.void;
+				const unbounded = Option.flatMap(optionsIndex(node.callee, namespaces), (index) => Option.flatMap(expressionArgument(node, index), unboundedConcurrency));
+				return Option.match(unbounded, {
+					onNone: () => Effect.void,
+					onSome: (value) => ctx.report(make({
+						node: value,
+						message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-unbounded-retry.js

@@ -2,7 +2,10 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unbounded-retry.ts
 const unboundedConstructors = new Set([
@@ -12,68 +15,49 @@ const unboundedConstructors = new Set([
 ]);
 const boundedCombinators = new Set(["take"]);
 const staticPropertyName = (node) => {
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return;
-	return node.property.name;
-};
-const hasOwnProperty = (node, name) => {
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (property.key.type === "Identifier" && property.key.name === name) return true;
-		if (property.key.type === "Literal" && property.key.value === name) return true;
-	}
-	return false;
-};
-const propertyValue = (node, name) => {
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) return property.value;
-	}
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return Option.none();
+	return Option.some(node.property.name);
 };
 const isBoundedOperation = (node, scheduleNamespaces) => {
 	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
-	const property = staticPropertyName(node.callee);
-	if (property === void 0) return false;
-	if (boundedCombinators.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return true;
-	if (!isStaticMember(node.callee, scheduleNamespaces, "both")) return false;
-	const bound = node.arguments[0];
-	return bound !== void 0 && bound.type !== "SpreadElement" && isStaticCall(bound, scheduleNamespaces, "recurs");
+	const callee = node.callee;
+	if (Option.exists(staticPropertyName(callee), (property) => boundedCombinators.has(property) && isStaticMember(callee, scheduleNamespaces, property))) return true;
+	if (!isStaticMember(callee, scheduleNamespaces, "both")) return false;
+	return Option.exists(expressionArgument(node, 0), (bound) => isStaticCall(bound, scheduleNamespaces, "recurs"));
 };
 const unboundedSchedule = (node, scheduleNamespaces) => {
-	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return node;
-	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
-	const property = staticPropertyName(node.callee);
-	if (property !== void 0 && unboundedConstructors.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return node;
-	if (property !== "pipe" || node.callee.type !== "MemberExpression") return void 0;
-	const root = unboundedSchedule(node.callee.object, scheduleNamespaces);
-	if (root === void 0) return void 0;
-	for (const operation of node.arguments) if (isBoundedOperation(operation, scheduleNamespaces)) return void 0;
-	return root;
+	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return Option.some(node);
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return Option.none();
+	const callee = node.callee;
+	const property = staticPropertyName(callee);
+	if (Option.exists(property, (name) => unboundedConstructors.has(name) && isStaticMember(callee, scheduleNamespaces, name))) return Option.some(node);
+	if (!Option.contains(property, "pipe") || callee.type !== "MemberExpression") return Option.none();
+	return Option.filter(unboundedSchedule(callee.object, scheduleNamespaces), () => !node.arguments.some((operation) => isBoundedOperation(operation, scheduleNamespaces)));
+};
+/** Arguments a data-last retry call takes; one more means the data-first form. */
+const retryArity = (callee, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "retryOrElse")) return Option.some(2);
+	if (isStaticMember(callee, effectNamespaces, "retry") || isStaticMember(callee, streamNamespaces, "retry") || isStaticMember(callee, httpClientNamespaces, "retryTransient")) return Option.some(1);
+	return Option.none();
+};
+/** The policy argument: first in the data-last form, second in the data-first form. */
+const policyArgument = (node, arity) => {
+	if (node.arguments.length < arity) return Option.none();
+	let policyIndex = 1;
+	if (node.arguments.length === arity) policyIndex = 0;
+	return Arr.get(node.arguments, policyIndex);
+};
+/** The schedule a policy argument retries on, unless it sets `times`. */
+const policySchedule = (policy) => {
+	if (policy.type === "SpreadElement") return Option.none();
+	if (policy.type !== "ObjectExpression") return Option.some(policy);
+	if (Arr.isReadonlyArrayNonEmpty(staticProperties(policy, "times"))) return Option.none();
+	return Option.map(Arr.head(staticProperties(policy, "schedule")), (property) => property.value);
 };
 const retryPolicy = (node, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
-	if (node.callee.type === "Super") return void 0;
-	let policyIndex;
-	if (isStaticMember(node.callee, effectNamespaces, "retry")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, effectNamespaces, "retryOrElse")) {
-		if (node.arguments.length === 2) policyIndex = 0;
-		if (node.arguments.length >= 3) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, streamNamespaces, "retry")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (isStaticMember(node.callee, httpClientNamespaces, "retryTransient")) {
-		if (node.arguments.length === 1) policyIndex = 0;
-		if (node.arguments.length >= 2) policyIndex = 1;
-	}
-	if (policyIndex === void 0) return void 0;
-	const policy = node.arguments[policyIndex];
-	if (policy?.type === "SpreadElement") return void 0;
-	if (policy?.type !== "ObjectExpression") return policy;
-	if (hasOwnProperty(policy, "times")) return void 0;
-	return propertyValue(policy, "schedule");
+	if (node.callee.type === "Super") return Option.none();
+	const arity = retryArity(node.callee, effectNamespaces, streamNamespaces, httpClientNamespaces);
+	return Option.flatMap(Option.flatMap(arity, (count) => policyArgument(node, count)), policySchedule);
 };
 const noUnboundedRetry = define({
 	name: "no-unbounded-retry",
@@ -99,13 +83,14 @@ const noUnboundedRetry = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression") return Effect.void;
 				const policy = retryPolicy(node, visibleNamespaces(ctx, node, effectNamespaces), visibleNamespaces(ctx, node, streamNamespaces), visibleNamespaces(ctx, node, httpClientNamespaces));
-				if (policy === void 0) return Effect.void;
-				const unbounded = unboundedSchedule(policy, visibleNamespaces(ctx, node, scheduleNamespaces));
-				if (unbounded === void 0) return Effect.void;
-				return ctx.report(make({
-					node: unbounded,
-					message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
-				}));
+				const unbounded = Option.flatMap(policy, (schedule) => unboundedSchedule(schedule, visibleNamespaces(ctx, node, scheduleNamespaces)));
+				return Option.match(unbounded, {
+					onNone: () => Effect.void,
+					onSome: (schedule) => ctx.report(make({
+						node: schedule,
+						message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-unknown-parameters.d.ts

@@ -1,7 +1,7 @@
 import * as _$_oxlint_plugins0 from "@oxlint/plugins";
 
 //#region src/rules/no-unknown-parameters.d.ts
-/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+/** Disallow unknown inputs except error-cause enrichment, type guards, and rejection handlers. */
 declare const noUnknownParameters: _$_oxlint_plugins0.CreateRule;
 //#endregion
 export { noUnknownParameters };

package/dist/rules/no-unknown-parameters.js

@@ -2,37 +2,46 @@ import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation } from "./_anti-slop-function-parameters.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-unknown-parameters.ts
-function parameterAnnotation(parameter) {
-	if (parameter.type === "TSParameterProperty") return parameterAnnotation(parameter.parameter);
-	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
-	if (parameter.type === "AssignmentPattern") return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
-	return parameter.typeAnnotation;
+function isTypePredicateSubject(owner, parameterName) {
+	const predicate = owner.returnType?.typeAnnotation;
+	return predicate?.type === "TSTypePredicate" && predicate.parameterName.type === "Identifier" && predicate.parameterName.name === parameterName;
 }
-function parameterName(parameter, sourceText) {
-	if (parameter.type === "TSParameterProperty") return parameterName(parameter.parameter, sourceText);
-	if (parameter.type === "AssignmentPattern") return parameterName(parameter.left, sourceText);
-	if (parameter.type === "RestElement") return parameterName(parameter.argument, sourceText);
-	return parameter.type === "Identifier" ? parameter.name : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
+/**
+* Whether the function is a promise rejection handler: the argument to `.catch`
+* or the second argument to `.then`. Its first parameter is the function form of
+* a `catch` clause binding and receives `unknown` by nature.
+*/
+function isRejectionHandler(owner) {
+	if (owner.type !== "ArrowFunctionExpression" && owner.type !== "FunctionExpression") return false;
+	const call = owner.parent;
+	if (call?.type !== "CallExpression" || call.callee.type !== "MemberExpression" || call.callee.computed || call.callee.property.type !== "Identifier") return false;
+	const position = call.arguments.indexOf(owner);
+	const method = call.callee.property.name;
+	return method === "catch" && position === 0 || method === "then" && position === 1;
 }
-/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+/** Disallow unknown inputs except error-cause enrichment, type guards, and rejection handlers. */
 const noUnknownParameters = define({
 	name: "no-unknown-parameters",
 	meta: meta({
 		type: "problem",
-		description: "Disallow explicitly unknown function parameters except `cause`; decode unknown input at its I/O boundary instead.",
+		description: "Disallow explicitly unknown function parameters except `cause`, type-predicate subjects, and the reason a promise rejection handler receives; decode unknown input at its I/O boundary instead.",
 		messages: { unknownParameter: "Parameter `{{parameter}}` accepts `unknown` without establishing its contract. Define the expected schema or parser so the value becomes a strongly typed domain type at the earliest possible point, as close as possible to the I/O boundary where the data originated." }
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
 		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
-			const annotation = parameterAnnotation(parameter);
-			if (annotation?.typeAnnotation.type !== "TSUnknownKeyword") return Effect.void;
-			const name = parameterName(parameter, context.sourceCode.getText(parameter));
-			if (name === "cause") return Effect.void;
+			const annotation = functionParameterTypeAnnotation(parameter);
+			if (Option.isNone(annotation)) return Effect.void;
+			const type = annotation.value.typeAnnotation;
+			if (!containsUnknownType(type)) return Effect.void;
+			const name = functionParameterBindingName(parameter, context.sourceCode);
+			if (name === "cause" || isTypePredicateSubject(node, name) || parameter === node.params[0] && isRejectionHandler(node)) return Effect.void;
 			return context.report(fromId({
-				node: annotation.typeAnnotation,
+				node: type,
 				messageId: "unknownParameter",
 				data: { parameter: name }
 			}));

package/dist/rules/no-unknown-returns.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unknown-returns.d.ts
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+declare const noUnknownReturns: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnknownReturns };

package/dist/rules/no-unknown-returns.js

@@ -0,0 +1,74 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { ancestors } from "./_ast-ancestors.js";
+import { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unknown-returns.ts
+/**
+* Whether the node sits in a type pattern rather than a contract: the `extends`
+* clause of a conditional type or a type parameter constraint. There
+* `(...args: never[]) => unknown` matches any function; it promises nothing.
+* (Local change: upstream reports these.)
+*/
+function isInsideTypePattern(node) {
+	let child = node;
+	for (const parent of ancestors(node)) {
+		if (parent.type === "TSConditionalType" && parent.extendsType === child) return true;
+		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
+		child = parent;
+	}
+	return false;
+}
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+const noUnknownReturns = define({
+	name: "no-unknown-returns",
+	meta: meta({
+		type: "problem",
+		description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+		messages: { unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		let environment = Option.none();
+		const resolvesToUnknown = (type) => Option.exists(environment, (present) => resolvedTypeMatches(type, present, (resolved, matches) => {
+			if (resolved.type === "TSUnknownKeyword") return true;
+			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
+			if (resolved.type === "TSUnionType") return resolved.types.some(matches);
+			if (resolved.type !== "TSTypeReference" || resolved.typeName.type !== "Identifier" || resolved.typeName.name !== "Promise" && resolved.typeName.name !== "PromiseLike") return false;
+			return Option.exists(Arr.head(resolved.typeArguments?.params ?? []), matches);
+		}));
+		const checkReturnType = (node) => {
+			const annotation = node.returnType;
+			if (Predicate.isNullish(annotation)) return Effect.void;
+			if (!resolvesToUnknown(annotation.typeAnnotation)) return Effect.void;
+			if (isInsideTypePattern(node)) return Effect.void;
+			return context.report(fromId({
+				node: annotation.typeAnnotation,
+				messageId: "unknownReturn"
+			}));
+		};
+		return {
+			Program: (node) => {
+				environment = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
+				return Effect.void;
+			},
+			ArrowFunctionExpression: checkReturnType,
+			FunctionDeclaration: checkReturnType,
+			FunctionExpression: checkReturnType,
+			TSCallSignatureDeclaration: checkReturnType,
+			TSConstructSignatureDeclaration: checkReturnType,
+			TSConstructorType: checkReturnType,
+			TSDeclareFunction: checkReturnType,
+			TSEmptyBodyFunctionExpression: checkReturnType,
+			TSFunctionType: checkReturnType,
+			TSMethodSignature: checkReturnType
+		};
+	}
+});
+//#endregion
+export { noUnknownReturns };