oxlint-plugin-effect 0.12.1 → 0.14.0

package/dist/rules/no-effect-run-in-tests.d.ts

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

package/dist/rules/no-effect-run-in-tests.js

@@ -0,0 +1,57 @@
+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 { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isTestFile, skipFile } from "./_test-files.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-effect-run-in-tests.ts
+const effectRunners = [
+	"runCallback",
+	"runCallbackWith",
+	"runFork",
+	"runForkWith",
+	"runPromise",
+	"runPromiseExit",
+	"runPromiseExitWith",
+	"runPromiseWith",
+	"runSync",
+	"runSyncExit",
+	"runSyncExitWith",
+	"runSyncWith"
+];
+const noEffectRunInTests = define({
+	name: "no-effect-run-in-tests",
+	meta: meta({
+		type: "problem",
+		description: "Run Effects in tests through it.effect or it.layer instead of Effect.run* or ManagedRuntime.make."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFile(ctx.filename)) return skipFile;
+		const effectNamespaces = new Set(["Effect"]);
+		const managedRuntimeNamespaces = new Set(["ManagedRuntime"]);
+		const runnerName = (node) => {
+			if (isStaticMember(node, visibleNamespaces(ctx, node, managedRuntimeNamespaces), "make")) return "ManagedRuntime.make";
+			const effects = visibleNamespaces(ctx, node, effectNamespaces);
+			return effectRunners.find((runner) => isStaticMember(node, effects, runner));
+		};
+		return {
+			ImportDeclaration: (node) => {
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "ManagedRuntime", "effect/ManagedRuntime")) managedRuntimeNamespaces.add(name);
+				return Effect.void;
+			},
+			MemberExpression: (node) => {
+				const runner = runnerName(node);
+				if (runner === void 0) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: `Do not run Effects by hand in tests (${runner}). Use the test runner's Effect integration: it.effect(...) or it.layer(layer)(...) from @effect/vitest or effect-bun-test.`
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noEffectRunInTests };

package/dist/rules/no-known-value-widening.js

@@ -3,26 +3,18 @@ import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression } from "./_anti-slop-dictionary-types.js";
+import { resolveVariable } from "./_anti-slop-scope.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-known-value-widening.ts
 /**
 * Ported from dmmulroy/anti-slop at
-* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+* c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b.
 */
 function unwrapExpression(expression) {
 	let current = expression;
 	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
 	return current;
 }
-function resolveVariable(sourceCode, identifier) {
-	let scope = sourceCode.getScope(identifier);
-	while (scope !== null) {
-		const variable = scope.set.get(identifier.name);
-		if (variable !== void 0) return variable;
-		scope = scope.upper;
-	}
-	return null;
-}
 function variableDeclarator(variable) {
 	if (variable.defs.length !== 1) return null;
 	const [definition] = variable.defs;
@@ -87,9 +79,9 @@ const noKnownValueWidening = define({
 	create: function* () {
 		const context = yield* RuleContext;
 		let environment = null;
-		const reportFlow = (expression, destination, subject, options = {}) => {
+		const reportFlow = (expression, destination, subject) => {
 			if (destination === null) return Effect.void;
-			if (options.allowEmptyDictionaryAccumulator === true && isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return Effect.void;
+			if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return Effect.void;
 			if (!hasKnownEvidence(context.sourceCode, expression)) return Effect.void;
 			return context.report(fromId({
 				node: expression,
@@ -103,12 +95,12 @@ const noKnownValueWidening = define({
 		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
 		return {
 			Program: (node) => {
-				environment = createTypeEnvironment(node);
+				environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
 				return Effect.void;
 			},
 			VariableDeclarator: (node) => {
 				if (node.init === null || node.id.type !== "Identifier") return Effect.void;
-				return reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``, { allowEmptyDictionaryAccumulator: true });
+				return reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
 			},
 			PropertyDefinition: (node) => {
 				if (node.value === null) return Effect.void;

package/dist/rules/no-module-level-mutable-state.d.ts

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

package/dist/rules/no-module-level-mutable-state.js

@@ -0,0 +1,51 @@
+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 { isTestFile, skipFile } from "./_test-files.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-module-level-mutable-state.ts
+/** Nodes that start a new `var` scope, so a `var` below them is not module state. */
+const functionScopeBoundaries = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"StaticBlock",
+	"TSDeclareFunction",
+	"TSModuleBlock"
+]);
+const isModuleScopedVar = (node) => {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (functionScopeBoundaries.has(current.type)) return false;
+		current = current.parent;
+	}
+	return current !== null;
+};
+const noModuleLevelMutableState = define({
+	name: "no-module-level-mutable-state",
+	meta: meta({
+		type: "problem",
+		description: "Keep state out of module-level let and var bindings."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (isTestFile(ctx.filename)) return skipFile;
+		const isModuleScoped = (node) => {
+			if (node.kind === "var") return isModuleScopedVar(node);
+			const scope = ctx.sourceCode.getScope(node);
+			return scope.type === "module" || scope.type === "global";
+		};
+		return { VariableDeclaration: (node) => {
+			if (node.declare === true) return Effect.void;
+			if (node.kind !== "let" && node.kind !== "var") return Effect.void;
+			if (!isModuleScoped(node)) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: `Module-level ${node.kind} is shared by every request a server process or Worker isolate handles. Keep the state in a Ref built by a Layer, or in the service that owns it.`
+			}));
+		} };
+	}
+});
+//#endregion
+export { noModuleLevelMutableState };

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

@@ -2,17 +2,10 @@ 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 { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+import { functionParameterBindingName, functionParameterTypeAnnotation } from "./_anti-slop-function-parameters.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-object-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 parameterName(parameter, sourceCode) {
-	return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
-}
 /** Ban the broad object type on function inputs, including local aliases to object. */
 const noObjectParameters = define({
 	name: "no-object-parameters",
@@ -23,34 +16,25 @@ const noObjectParameters = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const aliases = /* @__PURE__ */ new Map();
-		const resolvesToObject = (type, visited = /* @__PURE__ */ new Set()) => {
-			if (type.type === "TSObjectKeyword") return true;
-			if (type.type === "TSParenthesizedType") return resolvesToObject(type.typeAnnotation, visited);
-			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject(member, visited));
-			if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeArguments !== null && type.typeArguments !== void 0 && type.typeArguments.params.length > 0 || visited.has(type.typeName.name)) return false;
-			const alias = aliases.get(type.typeName.name);
-			if (alias === void 0) return false;
-			const nextVisited = new Set(visited);
-			nextVisited.add(type.typeName.name);
-			return resolvesToObject(alias, nextVisited);
-		};
+		let environment = null;
+		const resolvesToObject = (type) => environment !== null && resolvedTypeMatches(type, environment, (resolved, matches) => {
+			if (resolved.type === "TSObjectKeyword") return true;
+			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
+			return resolved.type === "TSUnionType" && resolved.types.some(matches);
+		});
 		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
-			const annotation = parameterAnnotation(parameter);
+			const annotation = functionParameterTypeAnnotation(parameter);
 			if (annotation === null || annotation === void 0) return Effect.void;
 			if (!resolvesToObject(annotation.typeAnnotation)) return Effect.void;
 			return context.report(fromId({
 				node: annotation.typeAnnotation,
 				messageId: "objectParameter",
-				data: { parameter: parameterName(parameter, context.sourceCode) }
+				data: { parameter: functionParameterBindingName(parameter, context.sourceCode) }
 			}));
 		}, { discard: true });
 		return {
 			Program: (node) => {
-				for (const statement of node.body) {
-					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-					if (declaration?.type === "TSTypeAliasDeclaration" && (declaration.typeParameters === null || declaration.typeParameters === void 0)) aliases.set(declaration.id.name, declaration.typeAnnotation);
-				}
+				environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
 				return Effect.void;
 			},
 			ArrowFunctionExpression: checkParameters,

package/dist/rules/no-reduce-accumulator-copy.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reduce-accumulator-copy.d.ts
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+declare const noReduceAccumulatorCopy: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReduceAccumulatorCopy };

package/dist/rules/no-reduce-accumulator-copy.js

@@ -0,0 +1,94 @@
+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 { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression } from "./_anti-slop-array-method.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reduce-accumulator-copy.ts
+const arrayCopyMethods = new Set([
+	"concat",
+	"slice",
+	"toSpliced",
+	"toSorted",
+	"toReversed",
+	"with"
+]);
+function enclosingReducer(node) {
+	let parent = node.parent;
+	while (parent !== null) {
+		if (parent.type === "FunctionDeclaration") return null;
+		if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+			const callback = parent;
+			let owner = callback.parent;
+			while (owner !== null && unwrapArrayExpression(owner) === callback) owner = owner.parent;
+			if (owner?.type !== "CallExpression") return null;
+			const method = arrayMethodTarget(owner.callee);
+			const firstArgument = owner.arguments[0];
+			if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === void 0 || unwrapArrayExpression(firstArgument) !== callback) return null;
+			const firstParameter = callback.params[0];
+			const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+			if (accumulator?.type !== "Identifier") return null;
+			return {
+				callback,
+				accumulator,
+				initialValue: owner.arguments[1]
+			};
+		}
+		parent = parent.parent;
+	}
+	return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = /* @__PURE__ */ new Set()) {
+	const variable = resolveArrayBinding(sourceCode, node);
+	if (variable === null || visited.has(variable)) return false;
+	if (variable === accumulator) return true;
+	visited.add(variable);
+	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+	return false;
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+	const owner = unwrapArrayExpression(node);
+	if (owner.type !== "Identifier" || owner.name !== name) return false;
+	const variable = resolveArrayBinding(sourceCode, owner);
+	return variable === null || variable.defs.length === 0;
+}
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+const noReduceAccumulatorCopy = define({
+	name: "no-reduce-accumulator-copy",
+	meta: meta({
+		type: "problem",
+		description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods.",
+		messages: { accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const { sourceCode } = context;
+		const copiesAccumulator = (node) => {
+			const method = arrayMethodTarget(node.callee);
+			if (method === null) return false;
+			const reducer = enclosingReducer(node);
+			if (reducer === null) return false;
+			const accumulator = sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+			if (accumulator === void 0) return false;
+			const isAccumulator = (expression) => referencesAccumulator(sourceCode, expression, accumulator);
+			if (method.name === "assign" && isGlobalCopyOwner(sourceCode, method.object, "Object")) {
+				const target = node.arguments[0];
+				return target !== void 0 && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
+			}
+			if (method.name === "from" && isGlobalCopyOwner(sourceCode, method.object, "Array")) {
+				const source = node.arguments[0];
+				return source !== void 0 && isAccumulator(source);
+			}
+			if (!arrayCopyMethods.has(method.name)) return false;
+			const initialValue = reducer.initialValue;
+			return initialValue !== void 0 && isKnownArrayExpression(sourceCode, initialValue) && isAccumulator(method.object);
+		};
+		return { CallExpression: (node) => copiesAccumulator(node) ? context.report(fromId({
+			node,
+			messageId: "accumulatorCopy"
+		})) : Effect.void };
+	}
+});
+//#endregion
+export { noReduceAccumulatorCopy };

package/dist/rules/no-reflect-apply.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reflect-apply.d.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+declare const noReflectApply: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReflectApply };

package/dist/rules/no-reflect-apply.js

@@ -0,0 +1,25 @@
+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 { isGlobalReflectMethodCall } from "./_anti-slop-reflect-method.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reflect-apply.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+const noReflectApply = define({
+	name: "no-reflect-apply",
+	meta: meta({
+		type: "problem",
+		description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+		messages: { reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { CallExpression: (node) => node.callee.type !== "Super" && isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply") ? context.report(fromId({
+			node,
+			messageId: "reflectApply"
+		})) : Effect.void };
+	}
+});
+//#endregion
+export { noReflectApply };

package/dist/rules/no-reflect-get.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reflect-get.d.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+declare const noReflectGet: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReflectGet };

package/dist/rules/no-reflect-get.js

@@ -0,0 +1,25 @@
+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 { isGlobalReflectMethodCall } from "./_anti-slop-reflect-method.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reflect-get.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+const noReflectGet = define({
+	name: "no-reflect-get",
+	meta: meta({
+		type: "problem",
+		description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+		messages: { reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { CallExpression: (node) => node.callee.type !== "Super" && isGlobalReflectMethodCall(context.sourceCode, node.callee, "get") ? context.report(fromId({
+			node,
+			messageId: "reflectGet"
+		})) : Effect.void };
+	}
+});
+//#endregion
+export { noReflectGet };

package/dist/rules/no-runtime-typeof.js

@@ -4,6 +4,19 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-runtime-typeof.ts
+/** Whether `typeof` probes for a possibly absent binding, which only `typeof` can do safely. */
+function isExistenceProbe(node) {
+	const parent = node.parent;
+	if (parent?.type !== "BinaryExpression") return false;
+	if (![
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(parent.operator)) return false;
+	const other = parent.left === node ? parent.right : parent.left;
+	return other.type === "Literal" && other.value === "undefined";
+}
 /** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
 const noRuntimeTypeof = define({
 	name: "no-runtime-typeof",
@@ -14,7 +27,7 @@ const noRuntimeTypeof = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { UnaryExpression: (node) => node.operator === "typeof" ? context.report(fromId({
+		return { UnaryExpression: (node) => node.operator === "typeof" && !isExistenceProbe(node) ? context.report(fromId({
 			node,
 			messageId: "runtimeTypeof"
 		})) : Effect.void };

package/dist/rules/no-shape-in-symbol-names.js

@@ -8,6 +8,12 @@ const forbiddenSymbolName = "shape";
 function containsForbiddenSymbolName(name) {
 	return name.toLowerCase().includes(forbiddenSymbolName);
 }
+/** Return whether an identifier names a statically accessed member owned by another value. */
+function isBorrowedMemberName(node) {
+	const parent = node.parent;
+	if (parent === null || parent.type !== "MemberExpression") return false;
+	return parent.property === node && !parent.computed;
+}
 /** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
 const noShapeInSymbolNames = define({
 	name: "no-shape-in-symbol-names",
@@ -18,7 +24,7 @@ const noShapeInSymbolNames = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const reportForbiddenSymbolName = (node) => containsForbiddenSymbolName(node.name) ? context.report(fromId({
+		const reportForbiddenSymbolName = (node) => containsForbiddenSymbolName(node.name) && !isBorrowedMemberName(node) ? context.report(fromId({
 			node,
 			messageId: "forbiddenSymbolName",
 			data: { name: node.name }

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,35 +2,42 @@ 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 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 (annotation === null || annotation === void 0) return Effect.void;
+			if (!containsUnknownType(annotation.typeAnnotation)) 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,
 				messageId: "unknownParameter",

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,73 @@
+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 { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+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;
+	let parent = node.parent;
+	while (parent !== null && parent.type !== "Program") {
+		if (parent.type === "TSConditionalType" && parent.extendsType === child) return true;
+		if (parent.type === "TSTypeParameter" && parent.constraint === child) return true;
+		child = parent;
+		parent = parent.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 = null;
+		const resolvesToUnknown = (type) => environment !== null && resolvedTypeMatches(type, environment, (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;
+			const value = resolved.typeArguments?.params[0];
+			return value !== void 0 && matches(value);
+		});
+		const checkReturnType = (node) => {
+			const annotation = node.returnType;
+			if (annotation === null || annotation === void 0) 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 = 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 };