oxlint-plugin-effect 0.14.0 → 0.15.0

package/dist/rules/no-globals.js

@@ -147,7 +147,6 @@ const isUnshadowedGlobal = (ctx, node, name) => Option.match(findVariableUp(ctx.
 	onNone: () => true,
 	onSome: (variable) => variable.defs.length === 0
 });
-const staticMember = (node) => Option.getOrUndefined(memberNames(node));
 const processStreams = new Set([
 	"stderr",
 	"stdin",
@@ -176,37 +175,49 @@ const noGlobals = define({
 			node,
 			message: `Avoid ${used}. Use ${alternative}; platform adapters may disable this rule explicitly.`
 		}));
-		return {
-			MemberExpression: (node) => {
-				const memberExpression = Option.getOrUndefined(narrow(node, "MemberExpression"));
-				if (memberExpression === void 0) return Effect.void;
-				if (isCryptoDigest(memberExpression) && isUnshadowedGlobal(ctx, memberExpression, "crypto")) return report(memberExpression, "crypto.subtle.digest", "Crypto.digest");
-				const names = staticMember(memberExpression);
-				if (names === void 0) return Effect.void;
-				const [object, property] = names;
-				if (!isUnshadowedGlobal(ctx, memberExpression, object)) return Effect.void;
-				for (const [bannedObject, properties, alternative] of memberBans) if (object === bannedObject && properties.has(property)) {
-					if (object === "process" && processStreams.has(property) && isTtyRead(memberExpression)) return Effect.void;
-					return report(memberExpression, `${object}.${property}`, alternative);
+		const reportMember = (memberExpression) => {
+			if (isCryptoDigest(memberExpression) && isUnshadowedGlobal(ctx, memberExpression, "crypto")) return report(memberExpression, "crypto.subtle.digest", "Crypto.digest");
+			return Option.match(memberNames(memberExpression), {
+				onNone: () => Effect.void,
+				onSome: ([object, property]) => {
+					if (!isUnshadowedGlobal(ctx, memberExpression, object)) return Effect.void;
+					for (const [bannedObject, properties, alternative] of memberBans) if (object === bannedObject && properties.has(property)) {
+						if (object === "process" && processStreams.has(property) && isTtyRead(memberExpression)) return Effect.void;
+						return report(memberExpression, `${object}.${property}`, alternative);
+					}
+					return Effect.void;
 				}
-				return Effect.void;
-			},
-			CallExpression: (node) => {
-				const call = Option.getOrUndefined(narrow(node, "CallExpression"));
-				if (call === void 0) return Effect.void;
-				const name = Option.getOrUndefined(calleeName(call));
-				if (name === void 0 || !isUnshadowedGlobal(ctx, call, name)) return Effect.void;
-				const alternative = callBans.get(name);
-				return alternative === void 0 ? Effect.void : report(call, `${name}()`, alternative);
-			},
-			NewExpression: (node) => {
-				const expression = Option.getOrUndefined(narrow(node, "NewExpression"));
-				if (expression === void 0 || expression.callee.type !== "Identifier") return Effect.void;
-				const name = expression.callee.name;
-				if (!isUnshadowedGlobal(ctx, expression, name)) return Effect.void;
-				const alternative = constructorBans.get(name);
-				return alternative === void 0 ? Effect.void : report(expression, `new ${name}()`, alternative);
-			}
+			});
+		};
+		const reportCall = (call) => Option.match(Option.filter(calleeName(call), (name) => isUnshadowedGlobal(ctx, call, name)), {
+			onNone: () => Effect.void,
+			onSome: (name) => Option.match(Option.fromUndefinedOr(callBans.get(name)), {
+				onNone: () => Effect.void,
+				onSome: (alternative) => report(call, `${name}()`, alternative)
+			})
+		});
+		const reportConstructor = (expression) => {
+			if (expression.callee.type !== "Identifier") return Effect.void;
+			const name = expression.callee.name;
+			if (!isUnshadowedGlobal(ctx, expression, name)) return Effect.void;
+			return Option.match(Option.fromUndefinedOr(constructorBans.get(name)), {
+				onNone: () => Effect.void,
+				onSome: (alternative) => report(expression, `new ${name}()`, alternative)
+			});
+		};
+		return {
+			MemberExpression: (node) => Option.match(narrow(node, "MemberExpression"), {
+				onNone: () => Effect.void,
+				onSome: reportMember
+			}),
+			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+				onNone: () => Effect.void,
+				onSome: reportCall
+			}),
+			NewExpression: (node) => Option.match(narrow(node, "NewExpression"), {
+				onNone: () => Effect.void,
+				onSome: reportConstructor
+			})
 		};
 	}
 });

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

@@ -2,8 +2,12 @@ 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 { classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression } from "./_anti-slop-dictionary-types.js";
 import { resolveVariable } from "./_anti-slop-scope.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-known-value-widening.ts
 /**
@@ -16,34 +20,44 @@ function unwrapExpression(expression) {
 	return current;
 }
 function variableDeclarator(variable) {
-	if (variable.defs.length !== 1) return null;
-	const [definition] = variable.defs;
-	return definition?.type === "Variable" && definition.node.type === "VariableDeclarator" ? definition.node : null;
+	if (variable.defs.length !== 1) return Option.none();
+	return Option.flatMap(Arr.head(variable.defs), (definition) => {
+		if (definition.type !== "Variable" || definition.node.type !== "VariableDeclarator") return Option.none();
+		return Option.some(definition.node);
+	});
 }
 function isStableConstVariable(variable, declarator) {
 	return declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const" && variable.references.every((reference) => reference.init || !reference.isWrite());
 }
+/**
+* The initializer of a variable's single const declarator that is never reassigned.
+* (Local change: split from hasKnownEvidence to read the Option-returning helpers.)
+*/
+function stableConstInitializer(variable) {
+	return Option.flatMap(Option.filter(variableDeclarator(variable), (declarator) => isStableConstVariable(variable, declarator)), (declarator) => Option.fromNullishOr(declarator.init));
+}
 function hasKnownEvidence(sourceCode, expression, visitedVariables = /* @__PURE__ */ new Set()) {
 	if (isKnownEvidenceExpression(expression)) return true;
 	const unwrapped = unwrapExpression(expression);
 	if (unwrapped.type !== "Identifier") return false;
 	const variable = resolveVariable(sourceCode, unwrapped);
-	if (variable === null || visitedVariables.has(variable)) return false;
-	const declarator = variableDeclarator(variable);
-	if (declarator === null || declarator.init === null || !isStableConstVariable(variable, declarator)) return false;
-	visitedVariables.add(variable);
-	return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+	if (Option.isNone(variable) || visitedVariables.has(variable.value)) return false;
+	const initializer = stableConstInitializer(variable.value);
+	if (Option.isNone(initializer)) return false;
+	visitedVariables.add(variable.value);
+	return hasKnownEvidence(sourceCode, initializer.value, visitedVariables);
 }
 function annotationTarget(annotation, environment) {
-	return annotation === null || annotation === void 0 ? null : classifyWideningTarget(annotation.typeAnnotation, environment);
+	return Option.flatMap(Option.all({
+		annotation,
+		environment
+	}), (present) => classifyWideningTarget(present.annotation.typeAnnotation, present.environment));
+}
+function isFunctionExpression(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
 function enclosingFunction(node) {
-	let current = node.parent;
-	while (current !== null && current.type !== "Program") {
-		if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") return current;
-		current = current.parent;
-	}
-	return null;
+	return Arr.findFirst(ancestors(node), isFunctionExpression);
 }
 function sourceKeyName(sourceCode, key) {
 	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
@@ -51,8 +65,13 @@ function sourceKeyName(sourceCode, key) {
 	return sourceCode.getText(key);
 }
 function functionName(sourceCode, owner) {
-	if (owner === null) return "anonymous function";
-	if (owner.id !== null) return owner.id.name;
+	return Option.match(owner, {
+		onNone: () => "anonymous function",
+		onSome: (present) => ownerFunctionName(sourceCode, present)
+	});
+}
+function ownerFunctionName(sourceCode, owner) {
+	if (Predicate.isNotNull(owner.id)) return owner.id.name;
 	const parent = owner.parent;
 	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
 	if (parent.type === "MethodDefinition") return sourceKeyName(sourceCode, parent.key);
@@ -78,57 +97,63 @@ const noKnownValueWidening = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		let environment = null;
+		let environment = Option.none();
 		const reportFlow = (expression, destination, subject) => {
-			if (destination === null) return Effect.void;
-			if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return Effect.void;
+			if (Option.isNone(destination)) return Effect.void;
+			const target = destination.value;
+			if (isDictionaryAccumulatorTarget(target) && isEmptyObjectExpression(expression)) return Effect.void;
 			if (!hasKnownEvidence(context.sourceCode, expression)) return Effect.void;
 			return context.report(fromId({
 				node: expression,
 				messageId: "widening",
 				data: {
 					subject,
-					target: destination.kind
+					target: target.kind
 				}
 			}));
 		};
-		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+		const targetFromAnnotation = (annotation) => annotationTarget(annotation, environment);
+		const reportAssertion = (node) => {
+			if (hasParentAssertion(node)) return Effect.void;
+			const target = Option.flatMap(environment, (present) => classifyWideningTarget(node.typeAnnotation, present));
+			return reportFlow(node.expression, target, "assertion");
+		};
 		return {
 			Program: (node) => {
-				environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+				environment = Option.some(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}\``);
+				if (Predicate.isNull(node.init) || node.id.type !== "Identifier") return Effect.void;
+				return reportFlow(node.init, targetFromAnnotation(Option.fromNullishOr(node.id.typeAnnotation)), `binding \`${node.id.name}\``);
 			},
 			PropertyDefinition: (node) => {
-				if (node.value === null) return Effect.void;
-				return reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+				if (Predicate.isNull(node.value)) return Effect.void;
+				return reportFlow(node.value, targetFromAnnotation(Option.fromNullishOr(node.typeAnnotation)), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
 			},
 			AccessorProperty: (node) => {
-				if (node.value === null) return Effect.void;
-				return reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+				if (Predicate.isNull(node.value)) return Effect.void;
+				return reportFlow(node.value, targetFromAnnotation(Option.fromNullishOr(node.typeAnnotation)), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
 			},
 			AssignmentExpression: (node) => {
 				if (node.operator !== "=" || node.left.type !== "Identifier") return Effect.void;
-				const variable = resolveVariable(context.sourceCode, node.left);
-				if (variable === null) return Effect.void;
-				const declarator = variableDeclarator(variable);
-				if (declarator === null || declarator.id.type !== "Identifier") return Effect.void;
-				return reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+				const declarator = Option.flatMap(resolveVariable(context.sourceCode, node.left), variableDeclarator);
+				if (Option.isNone(declarator)) return Effect.void;
+				const { id } = declarator.value;
+				if (id.type !== "Identifier") return Effect.void;
+				return reportFlow(node.right, targetFromAnnotation(Option.fromNullishOr(id.typeAnnotation)), `binding \`${id.name}\``);
 			},
 			ReturnStatement: (node) => {
-				if (node.argument === null) return Effect.void;
+				if (Predicate.isNull(node.argument)) return Effect.void;
 				const owner = enclosingFunction(node);
-				return reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+				return reportFlow(node.argument, targetFromAnnotation(Option.flatMap(owner, (present) => Option.fromNullishOr(present.returnType))), `return value of \`${functionName(context.sourceCode, owner)}\``);
 			},
 			ArrowFunctionExpression: (node) => {
 				if (node.body.type === "BlockStatement") return Effect.void;
-				return reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+				return reportFlow(node.body, targetFromAnnotation(Option.fromNullishOr(node.returnType)), `return value of \`${functionName(context.sourceCode, Option.some(node))}\``);
 			},
-			TSAsExpression: (node) => environment === null || hasParentAssertion(node) ? Effect.void : reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion"),
-			TSTypeAssertion: (node) => environment === null || hasParentAssertion(node) ? Effect.void : reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion")
+			TSAsExpression: reportAssertion,
+			TSTypeAssertion: reportAssertion
 		};
 	}
 });

package/dist/rules/no-module-level-mutable-state.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 { ancestors } from "./_ast-ancestors.js";
 import { isTestFile, skipFile } from "./_test-files.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 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. */
@@ -14,14 +17,7 @@ const functionScopeBoundaries = new Set([
 	"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 isModuleScopedVar = (node) => Option.exists(Arr.findFirst(ancestors(node), (ancestor) => ancestor.type === "Program" || functionScopeBoundaries.has(ancestor.type)), (boundary) => boundary.type === "Program");
 const noModuleLevelMutableState = define({
 	name: "no-module-level-mutable-state",
 	meta: meta({

package/dist/rules/no-module-mocks.js

@@ -1,25 +1,32 @@
-import { importSource, memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
+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 } from "../vendor/effect-oxlint/Scope.js";
 import "../vendor/effect-oxlint/index.js";
+import { collectTestBindings, resolveTestBinding } from "./_test-apis.js";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-module-mocks.ts
-const bannedMethods = new Set(["mock", "spyOn"]);
-const identifierName = (node) => {
-	if (node?.type === "Identifier") return node.name;
+const mockingMethods = new Set([
+	"doMock",
+	"fn",
+	"mock",
+	"mocked",
+	"spyOn",
+	"unmock"
+]);
+/** bun:test `mock(...)` and `spyOn(...)` are mock doubles in their own right. */
+const bannedBareCall = (binding) => {
+	if (binding === "mock" || binding === "spyOn") return Option.some(`${binding}()`);
+	return Option.none();
 };
-const globalTestApi = (name) => {
-	if (name === "jest" || name === "vi") return name;
-};
-const importedTestApi = (source, imported) => {
-	if (source === "vitest" && imported === "vi") return "vi";
-	if (source === "@jest/globals" && imported === "jest") return "jest";
-};
-const testApiFromVariable = (variable, importedBindings) => {
-	if (variable.defs.some((definition) => definition.type === "ImportBinding")) return importedBindings.get(variable.name);
+const bannedMemberCall = (binding, method) => {
+	if (binding === "mock") {
+		if (method === "module") return Option.some("mock.module()");
+		return Option.none();
+	}
+	if (binding === "spyOn" || !mockingMethods.has(method)) return Option.none();
+	return Option.some(`${binding}.${method}()`);
 };
 const noModuleMocks = define({
 	name: "no-module-mocks",
@@ -29,42 +36,24 @@ const noModuleMocks = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const importedBindings = /* @__PURE__ */ new Map();
+		const bindings = /* @__PURE__ */ new Map();
+		const bannedCall = (call) => {
+			const scope = context.sourceCode.getScope(call);
+			if (call.callee.type === "Identifier") return Option.flatMap(resolveTestBinding(scope, call.callee.name, bindings), bannedBareCall);
+			if (call.callee.type !== "MemberExpression") return Option.none();
+			return Option.flatMap(memberNames(call.callee), ([object, method]) => Option.flatMap(resolveTestBinding(scope, object, bindings), (binding) => bannedMemberCall(binding, method)));
+		};
 		return {
-			ImportDeclaration: (node) => Option.match(narrow(node, "ImportDeclaration"), {
-				onNone: () => Effect.void,
-				onSome: (declaration) => {
-					const source = importSource(declaration);
-					for (const specifier of declaration.specifiers) {
-						if (specifier.type !== "ImportSpecifier") continue;
-						const imported = identifierName(specifier.imported);
-						if (imported === void 0) continue;
-						const api = importedTestApi(source, imported);
-						if (api !== void 0) importedBindings.set(specifier.local.name, api);
-					}
-					return Effect.void;
-				}
-			}),
-			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+			ImportDeclaration: (node) => {
+				collectTestBindings(node, bindings);
+				return Effect.void;
+			},
+			CallExpression: (node) => Option.match(Option.flatMap(narrow(node, "CallExpression"), bannedCall), {
 				onNone: () => Effect.void,
-				onSome: (call) => {
-					if (call.callee.type !== "MemberExpression") return Effect.void;
-					const names = Option.getOrUndefined(memberNames(call.callee));
-					if (names === void 0) return Effect.void;
-					const [object, method] = names;
-					if (!bannedMethods.has(method)) return Effect.void;
-					const variable = Option.getOrUndefined(findVariableUp(context.sourceCode.getScope(call), object));
-					let api = globalTestApi(object);
-					if (variable !== void 0) {
-						api = testApiFromVariable(variable, importedBindings);
-						if (api === void 0 && variable.defs.length === 0) api = globalTestApi(object);
-					}
-					if (api === void 0) return Effect.void;
-					return context.report(make({
-						node: call,
-						message: `Avoid ${api}.${method}(). Replace the external boundary with an Effect service test Layer.`
-					}));
-				}
+				onSome: (used) => context.report(make({
+					node,
+					message: `Avoid ${used}. Replace the external boundary with an Effect service test Layer.`
+				}))
 			})
 		};
 	}

package/dist/rules/no-new-promise.js

@@ -22,14 +22,18 @@ const noNewPromise = define({
 		return {
 			NewExpression: (node) => Option.match(narrow(node, "NewExpression"), {
 				onNone: () => Effect.void,
-				onSome: (expression) => isPromiseIdentifier(expression.callee) ? report(expression) : Effect.void
+				onSome: (expression) => {
+					if (!isPromiseIdentifier(expression.callee)) return Effect.void;
+					return report(expression);
+				}
 			}),
 			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
 				onNone: () => Effect.void,
 				onSome: (call) => {
 					if (isPromiseIdentifier(call.callee)) return report(call);
 					if (call.callee.type !== "MemberExpression") return Effect.void;
-					return Option.getOrUndefined(memberNames(call.callee))?.[0] === "Promise" ? report(call) : Effect.void;
+					if (!Option.exists(memberNames(call.callee), ([object]) => object === "Promise")) return Effect.void;
+					return report(call);
 				}
 			})
 		};

package/dist/rules/no-node-builtin-import.js

@@ -3,7 +3,9 @@ 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 * 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-node-builtin-import.ts
 const replacedModules = new Map([
@@ -39,30 +41,47 @@ const processOperations = new Set([
 	"stdout"
 ]);
 const moduleBase = (source) => {
-	const withoutPrefix = source.startsWith("node:") ? source.slice(5) : source;
-	return withoutPrefix.split("/")[0] ?? withoutPrefix;
+	let withoutPrefix = source;
+	if (source.startsWith("node:")) withoutPrefix = source.slice(5);
+	return Option.getOrElse(Arr.head(withoutPrefix.split("/")), () => withoutPrefix);
+};
+const importedName = (specifier) => {
+	if (specifier.imported.type === "Identifier") return specifier.imported.name;
+	return specifier.imported.value;
 };
-const importedName = (specifier) => specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
 const memberPath = (node) => {
-	if (node.computed || node.property.type !== "Identifier") return void 0;
-	if (node.object.type === "Identifier") return [node.object.name, node.property.name];
-	if (node.object.type !== "MemberExpression") return void 0;
-	const parentPath = memberPath(node.object);
-	return parentPath === void 0 ? void 0 : [...parentPath, node.property.name];
+	if (node.computed || node.property.type !== "Identifier") return Option.none();
+	const property = node.property.name;
+	if (node.object.type === "Identifier") return Option.some([node.object.name, property]);
+	if (node.object.type !== "MemberExpression") return Option.none();
+	return Option.map(memberPath(node.object), (parentPath) => [...parentPath, property]);
+};
+/** Whether the segment before the operation in `path` is `name`. */
+const followsSegment = (path, name) => Option.contains(Arr.get(path, path.length - 2), name);
+const isDigestUnder = (operation, path, name) => operation === "digest" && followsSegment(path, name);
+const cryptoReplacement = (operation, path) => {
+	if (cryptoOperations.has(operation) && path.length === 2) return Option.some("Crypto");
+	if (followsSegment(path, "webcrypto") && cryptoOperations.has(operation)) return Option.some("Crypto");
+	if (isDigestUnder(operation, path, "subtle")) return Option.some("Crypto.digest");
+	return Option.none();
 };
-const partialReplacement = (module, path) => {
-	const operation = path.at(-1);
-	if (operation === void 0) return void 0;
-	if (module === "process") return processOperations.has(operation) && path.length === 2 ? "Config, Stdio, Clock, or Effect scheduling" : void 0;
-	if (module === "subtle") return operation === "digest" && path.length === 2 ? "Crypto.digest" : void 0;
+const replacementFor = (module, operation, path) => {
+	if (module === "process") {
+		if (processOperations.has(operation) && path.length === 2) return Option.some("Config, Stdio, Clock, or Effect scheduling");
+		return Option.none();
+	}
+	if (module === "subtle") {
+		if (operation === "digest" && path.length === 2) return Option.some("Crypto.digest");
+		return Option.none();
+	}
 	if (module === "webcrypto") {
-		if (cryptoOperations.has(operation) && path.length === 2) return "Crypto";
-		return operation === "digest" && path.at(-2) === "subtle" ? "Crypto.digest" : void 0;
+		if (cryptoOperations.has(operation) && path.length === 2) return Option.some("Crypto");
+		if (isDigestUnder(operation, path, "subtle")) return Option.some("Crypto.digest");
+		return Option.none();
 	}
-	if (cryptoOperations.has(operation) && path.length === 2) return "Crypto";
-	if (path.at(-2) === "webcrypto" && cryptoOperations.has(operation)) return "Crypto";
-	return operation === "digest" && path.at(-2) === "subtle" ? "Crypto.digest" : void 0;
+	return cryptoReplacement(operation, path);
 };
+const partialReplacement = (module, path) => Option.flatMap(Arr.last(path), (operation) => replacementFor(module, operation, path));
 const noNodeBuiltinImport = define({
 	name: "no-node-builtin-import",
 	meta: meta({
@@ -76,14 +95,17 @@ const noNodeBuiltinImport = define({
 			node,
 			message: `Avoid ${used}. Use ${alternative}; platform adapters may disable this rule explicitly.`
 		}));
+		/** The partially replaced module a member path starts from, if its root is an alias. */
+		const aliasedModule = (path) => Option.flatMap(Arr.head(path), (alias) => Option.fromUndefinedOr(partialModuleByAlias.get(alias)));
 		return {
 			ImportDeclaration: (node) => {
-				const declaration = Option.getOrUndefined(narrow(node, "ImportDeclaration"));
-				if (declaration === void 0) return Effect.void;
+				const narrowed = narrow(node, "ImportDeclaration");
+				if (Option.isNone(narrowed)) return Effect.void;
+				const declaration = narrowed.value;
 				const source = importSource(declaration);
 				const module = moduleBase(source);
 				const alternative = replacedModules.get(module);
-				if (alternative !== void 0) return report(declaration, `importing '${source}'`, alternative);
+				if (Predicate.isNotUndefined(alternative)) return report(declaration, `importing '${source}'`, alternative);
 				if (module !== "crypto" && module !== "process") return Effect.void;
 				const diagnostics = [];
 				for (const specifier of declaration.specifiers) {
@@ -99,18 +121,19 @@ const noNodeBuiltinImport = define({
 				}
 				return Effect.all(diagnostics, { discard: true });
 			},
-			MemberExpression: (node) => {
-				const member = Option.getOrUndefined(narrow(node, "MemberExpression"));
-				if (member === void 0) return Effect.void;
-				const path = memberPath(member);
-				if (path === void 0) return Effect.void;
-				const alias = path[0];
-				if (alias === void 0) return Effect.void;
-				const module = partialModuleByAlias.get(alias);
-				if (module === void 0) return Effect.void;
-				const alternative = partialReplacement(module, path);
-				return alternative === void 0 ? Effect.void : report(member, `${path.join(".")}`, alternative);
-			}
+			MemberExpression: (node) => Option.match(narrow(node, "MemberExpression"), {
+				onNone: () => Effect.void,
+				onSome: (member) => {
+					const replacement = Option.flatMap(memberPath(member), (path) => Option.map(Option.flatMap(aliasedModule(path), (module) => partialReplacement(module, path)), (alternative) => ({
+						path,
+						alternative
+					})));
+					return Option.match(replacement, {
+						onNone: () => Effect.void,
+						onSome: ({ path, alternative }) => report(member, `${path.join(".")}`, alternative)
+					});
+				}
+			})
 		};
 	}
 });

package/dist/rules/no-nullish.js

@@ -5,6 +5,7 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import { isGlobalReference } from "../vendor/effect-oxlint/SourceCode.js";
 import "../vendor/effect-oxlint/index.js";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-nullish.ts
 const message = "Avoid null and undefined. Use Option for presence or absence. Use a domain enum when the state has more than two cases.";
@@ -37,7 +38,10 @@ const noNullish = define({
 			}),
 			Literal: (node) => Option.match(narrow(node, "Literal"), {
 				onNone: () => Effect.void,
-				onSome: (literal) => literal.value === null && !("regex" in literal) && !isNullPrototypeArgument(literal) ? report(literal) : Effect.void
+				onSome: (literal) => {
+					if (!Predicate.isNull(literal.value) || "regex" in literal || isNullPrototypeArgument(literal)) return Effect.void;
+					return report(literal);
+				}
 			}),
 			TSNullKeyword: (node) => Option.match(narrow(node, "TSNullKeyword"), {
 				onNone: () => Effect.void,

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

@@ -4,6 +4,7 @@ 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 Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-object-parameters.ts
 /** Ban the broad object type on function inputs, including local aliases to object. */
@@ -16,25 +17,26 @@ const noObjectParameters = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		let environment = null;
-		const resolvesToObject = (type) => environment !== null && resolvedTypeMatches(type, environment, (resolved, matches) => {
+		let environment = Option.none();
+		const resolvesToObject = (type) => Option.exists(environment, (present) => resolvedTypeMatches(type, present, (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 = functionParameterTypeAnnotation(parameter);
-			if (annotation === null || annotation === void 0) return Effect.void;
-			if (!resolvesToObject(annotation.typeAnnotation)) return Effect.void;
+			if (Option.isNone(annotation)) return Effect.void;
+			const type = annotation.value.typeAnnotation;
+			if (!resolvesToObject(type)) return Effect.void;
 			return context.report(fromId({
-				node: annotation.typeAnnotation,
+				node: type,
 				messageId: "objectParameter",
 				data: { parameter: functionParameterBindingName(parameter, context.sourceCode) }
 			}));
 		}, { discard: true });
 		return {
 			Program: (node) => {
-				environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+				environment = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
 				return Effect.void;
 			},
 			ArrowFunctionExpression: checkParameters,

package/dist/rules/no-per-call-cache-construction.js

@@ -4,6 +4,7 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
 import { enclosingEffectProgram } from "./_effect-context.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-per-call-cache-construction.ts
 const cachedEffectOperations = new Set([
@@ -36,8 +37,7 @@ const noPerCallCacheConstruction = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const effects = visibleNamespaces(ctx, node, effectNamespaces);
-				const program = enclosingEffectProgram(node, effects);
-				if (program === void 0 || program[1] === "gen") return Effect.void;
+				if (!Option.exists(enclosingEffectProgram(node, effects), ([, kind]) => kind !== "gen")) return Effect.void;
 				const caches = visibleNamespaces(ctx, node, cacheNamespaces);
 				if (!(isOperation(node.callee, effects, cachedEffectOperations) || isOperation(node.callee, caches, cacheConstructors))) return Effect.void;
 				return ctx.report(make({