oxlint-plugin-effect 0.14.0 → 0.15.0

package/dist/rules/_tagged-control-flow.js

@@ -1,79 +1,57 @@
+import { ancestors } from "./_ast-ancestors.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_tagged-control-flow.ts
 const expressionKey = (node) => {
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "ThisExpression") return "this";
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return null;
-	const object = expressionKey(node.object);
-	if (object === null) return null;
-	return `${object}.${node.property.name}`;
+	if (node.type === "Identifier") return Option.some(node.name);
+	if (node.type === "ThisExpression") return Option.some("this");
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return Option.none();
+	const property = node.property.name;
+	return Option.map(expressionKey(node.object), (object) => `${object}.${property}`);
 };
 const stringLiteral = (node) => {
-	if (node.type !== "Literal") return null;
-	if (typeof node.value !== "string") return null;
-	return node.value;
+	if (node.type !== "Literal" || !Predicate.isString(node.value)) return Option.none();
+	return Option.some(node.value);
 };
 const taggedSubject = (node) => {
-	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier" || node.property.name !== "_tag") return null;
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier" || node.property.name !== "_tag") return Option.none();
 	return expressionKey(node.object);
 };
+/** `subjectSide._tag === "Tag"` read from one orientation of the comparison. */
+const orientedComparison = (subjectSide, tagSide) => Option.all({
+	subject: taggedSubject(subjectSide),
+	tag: stringLiteral(tagSide)
+});
 const tagComparison = (node) => {
-	if (node.type !== "BinaryExpression" || node.operator !== "===") return null;
-	const leftSubject = taggedSubject(node.left);
-	const rightTag = stringLiteral(node.right);
-	if (leftSubject !== null && rightTag !== null) return {
-		subject: leftSubject,
-		tag: rightTag
-	};
-	const rightSubject = taggedSubject(node.right);
-	const leftTag = stringLiteral(node.left);
-	if (rightSubject === null || leftTag === null) return null;
-	return {
-		subject: rightSubject,
-		tag: leftTag
-	};
+	if (node.type !== "BinaryExpression" || node.operator !== "===") return Option.none();
+	const { left, right } = node;
+	return Option.orElse(orientedComparison(left, right), () => orientedComparison(right, left));
 };
 const tagComparisonsInOr = (node) => {
-	if (node.type === "LogicalExpression" && node.operator === "||") {
-		const left = tagComparisonsInOr(node.left);
-		const right = tagComparisonsInOr(node.right);
-		if (left === null || right === null) return null;
-		return [...left, ...right];
-	}
-	const comparison = tagComparison(node);
-	if (comparison === null) return null;
-	return [comparison];
-};
-const hasOneTaggedSubject = (comparisons) => {
-	const first = comparisons[0];
-	if (first === void 0 || comparisons.length < 2) return false;
-	return comparisons.every((comparison) => comparison.subject === first.subject);
+	if (node.type === "LogicalExpression" && node.operator === "||") return Option.zipWith(tagComparisonsInOr(node.left), tagComparisonsInOr(node.right), (left, right) => [...left, ...right]);
+	return Option.map(tagComparison(node), (comparison) => [comparison]);
 };
+const hasOneTaggedSubject = (comparisons) => comparisons.length >= 2 && Option.exists(Arr.head(comparisons), (first) => comparisons.every((comparison) => comparison.subject === first.subject));
 const isEffectCall = (node, operation) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.object.type === "Identifier" && node.callee.object.name === "Effect" && node.callee.property.type === "Identifier" && node.callee.property.name === operation;
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
-const effectCallbackLocation = (node, operation) => {
-	let current = node.parent;
-	while (current !== void 0 && current !== null) {
-		if (isFunction(current)) {
-			const call = current.parent;
-			if (call?.type !== "CallExpression" || !isEffectCall(call, operation)) return null;
-			const index = call.arguments.indexOf(current);
-			if (index < 0) return null;
-			return {
-				argumentCount: call.arguments.length,
-				index
-			};
-		}
-		current = current.parent;
-	}
-	return null;
-};
-const isInsideCatchAllHandler = (node) => {
-	const location = effectCallbackLocation(node, "catchAll");
-	if (location === null) return false;
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+const callbackLocation = (callback, operation) => {
+	const call = callback.parent;
+	if (call?.type !== "CallExpression" || !isEffectCall(call, operation)) return Option.none();
+	const index = call.arguments.indexOf(callback);
+	if (index < 0) return Option.none();
+	return Option.some({
+		argumentCount: call.arguments.length,
+		index
+	});
+};
+/** Where the nearest enclosing function sits among the arguments of an `Effect.<operation>` call. */
+const effectCallbackLocation = (node, operation) => Option.flatMap(Arr.findFirst(ancestors(node), isFunction), (callback) => callbackLocation(callback, operation));
+const isInsideCatchAllHandler = (node) => Option.exists(effectCallbackLocation(node, "catchAll"), (location) => {
 	let handlerIndex = 1;
 	if (location.argumentCount === 1) handlerIndex = 0;
 	return location.index === handlerIndex;
-};
+});
 const taggedSwitchSubject = (node) => taggedSubject(node.discriminant);
 //#endregion
 export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparison, tagComparisonsInOr, taggedSwitchSubject };

package/dist/rules/_test-apis.js

@@ -0,0 +1,47 @@
+import { importSource, narrow } from "../vendor/effect-oxlint/AST.js";
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+//#region src/rules/_test-apis.ts
+const bindingsBySource = new Map([
+	["vitest", new Map([["vi", "vi"]])],
+	["@jest/globals", new Map([["jest", "jest"]])],
+	["bun:test", new Map([
+		["jest", "jest"],
+		["mock", "mock"],
+		["spyOn", "spyOn"],
+		["vi", "vi"]
+	])]
+]);
+/** Runner objects that exist as ambient globals when no import provides them. */
+const globalBinding = (name) => {
+	if (name === "jest" || name === "vi") return Option.some(name);
+	return Option.none();
+};
+const identifierName = (node) => {
+	if (node.type === "Identifier") return Option.some(node.name);
+	return Option.none();
+};
+/** Record each named import of a runner binding under its local name. */
+const collectTestBindings = (node, bindings) => {
+	const declaration = narrow(node, "ImportDeclaration");
+	if (Option.isNone(declaration)) return;
+	const bySource = Option.fromUndefinedOr(bindingsBySource.get(importSource(declaration.value)));
+	if (Option.isNone(bySource)) return;
+	for (const specifier of declaration.value.specifiers) {
+		if (specifier.type !== "ImportSpecifier") continue;
+		const binding = Option.flatMap(identifierName(specifier.imported), (imported) => Option.fromUndefinedOr(bySource.value.get(imported)));
+		if (Option.isSome(binding)) bindings.set(specifier.local.name, binding.value);
+	}
+};
+const bindingFromVariable = (variable, bindings) => {
+	if (variable.defs.some((definition) => definition.type === "ImportBinding")) return Option.fromUndefinedOr(bindings.get(variable.name));
+	return Option.none();
+};
+/** The runner binding `name` refers to at `scope`: an imported binding, or the unshadowed global. */
+const resolveTestBinding = (scope, name, bindings) => Option.match(findVariableUp(scope, name), {
+	onNone: () => globalBinding(name),
+	onSome: (variable) => Option.orElse(bindingFromVariable(variable, bindings), () => Option.filter(globalBinding(name), () => variable.defs.length === 0))
+});
+//#endregion
+export { collectTestBindings, resolveTestBinding };

package/dist/rules/index.d.ts

@@ -32,6 +32,7 @@ import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
 import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
+import { noTestGlobals } from "./no-test-globals.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
@@ -52,7 +53,7 @@ import { requireSuppressionReason } from "./require-suppression-reason.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { maxCognitiveComplexity, maxHalsteadDifficulty, noArrayFilterMap, noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEagerAcquire, noEffectBind, noEffectDo, noEffectRunInTests, noGlobals, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleLevelMutableState, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noReduceAccumulatorCopy, noReflectApply, noReflectGet, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownReturns, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn, requireSuppressionReason };
+  export { maxCognitiveComplexity, maxHalsteadDifficulty, noArrayFilterMap, noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEagerAcquire, noEffectBind, noEffectDo, noEffectRunInTests, noGlobals, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleLevelMutableState, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noReduceAccumulatorCopy, noReflectApply, noReflectGet, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestGlobals, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownReturns, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn, requireSuppressionReason };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -33,6 +33,7 @@ import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
 import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
+import { noTestGlobals } from "./no-test-globals.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
@@ -86,6 +87,7 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noShapeInSymbolNames: () => noShapeInSymbolNames,
 	noSilentCatchAll: () => noSilentCatchAll,
 	noTernary: () => noTernary,
+	noTestGlobals: () => noTestGlobals,
 	noTestLifecycleHooks: () => noTestLifecycleHooks,
 	noThrowStatement: () => noThrowStatement,
 	noTryCatch: () => noTryCatch,

package/dist/rules/no-array-filter-map.js

@@ -3,8 +3,25 @@ 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, unwrapArrayExpression } from "./_anti-slop-array-method.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-array-filter-map.ts
+const pairedMethod = (name) => {
+	if (name === "map") return Option.some("filter");
+	if (name === "filter") return Option.some("map");
+	return Option.none();
+};
+function filterMapPair(sourceCode, node) {
+	return Option.flatMap(arrayMethodTarget(node.callee), (outer) => Option.flatMap(pairedMethod(outer.name), (pairedName) => {
+		const innerCall = unwrapArrayExpression(outer.object);
+		if (innerCall.type !== "CallExpression") return Option.none();
+		const inner = Option.filter(arrayMethodTarget(innerCall.callee), (method) => method.name === pairedName && isKnownArrayExpression(sourceCode, method.object));
+		return Option.map(inner, (method) => ({
+			first: method.name,
+			second: outer.name
+		}));
+	}));
+}
 /** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
 const noArrayFilterMap = define({
 	name: "no-array-filter-map",
@@ -15,24 +32,17 @@ const noArrayFilterMap = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { CallExpression: (node) => {
-			const outer = arrayMethodTarget(node.callee);
-			if (outer === null || outer.name !== "map" && outer.name !== "filter") return Effect.void;
-			const innerCall = unwrapArrayExpression(outer.object);
-			if (innerCall.type !== "CallExpression") return Effect.void;
-			const inner = arrayMethodTarget(innerCall.callee);
-			const pairedName = outer.name === "map" ? "filter" : "map";
-			if (inner === null || inner.name !== pairedName) return Effect.void;
-			if (!isKnownArrayExpression(context.sourceCode, inner.object)) return Effect.void;
-			return context.report(fromId({
+		return { CallExpression: (node) => Option.match(filterMapPair(context.sourceCode, node), {
+			onNone: () => Effect.void,
+			onSome: ({ first, second }) => context.report(fromId({
 				node,
 				messageId: "arrayFilterMap",
 				data: {
-					first: inner.name,
-					second: outer.name
+					first,
+					second
 				}
-			}));
-		} };
+			}))
+		}) };
 	}
 });
 //#endregion

package/dist/rules/no-chained-type-assertions.js

@@ -46,10 +46,13 @@ const noChainedTypeAssertions = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const checkTypeAssertion = (node) => isOutermostAssertionInChain(node) && isForbiddenAssertionChain(node) ? context.report(fromId({
-			node,
-			messageId: "chained"
-		})) : Effect.void;
+		const checkTypeAssertion = (node) => {
+			if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "chained"
+			}));
+		};
 		return {
 			TSAsExpression: checkTypeAssertion,
 			TSTypeAssertion: checkTypeAssertion

package/dist/rules/no-conditional-empty-object-spread.js

@@ -26,10 +26,13 @@ const noConditionalEmptyObjectSpread = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { SpreadElement: (node) => node.parent?.type === "ObjectExpression" && isConditionalEmptyObjectSpread(node.argument) ? context.report(fromId({
-			node,
-			messageId: "avoid"
-		})) : Effect.void };
+		return { SpreadElement: (node) => {
+			if (node.parent?.type !== "ObjectExpression" || !isConditionalEmptyObjectSpread(node.argument)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "avoid"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-dynamic-imports.js

@@ -3,14 +3,20 @@ 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, parentOf } from "./_ast-ancestors.js";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-dynamic-imports.ts
-const identifierName = (node) => node?.type === "Identifier" ? node.name : void 0;
+const identifierName = (node) => {
+	if (node.type === "Identifier") return Option.some(node.name);
+	return Option.none();
+};
+const isIdentifierNamed = (node, name) => Option.contains(identifierName(node), name);
 const hasNamedBinding = (pattern) => {
 	if (pattern.type === "Identifier") return true;
 	if (pattern.type === "ObjectPattern") return pattern.properties.length > 0;
-	if (pattern.type === "ArrayPattern") return pattern.elements.some((element) => element !== null);
+	if (pattern.type === "ArrayPattern") return pattern.elements.some(Predicate.isNotNull);
 	return false;
 };
 const isNamedVariable = (node, value) => node.type === "VariableDeclarator" && node.init === value && hasNamedBinding(node.id);
@@ -22,42 +28,45 @@ const transparentWrappers = new Set([
 	"TSTypeAssertion",
 	"YieldExpression"
 ]);
+/** The outermost node reached from `start` through transparent wrapper ancestors. */
 const climbTransparent = (start) => {
 	let current = start;
-	while (current.parent != null && transparentWrappers.has(current.parent.type)) current = current.parent;
+	for (const parent of ancestors(start)) {
+		if (!transparentWrappers.has(parent.type)) break;
+		current = parent;
+	}
 	return current;
 };
 const isNamedDirectBinding = (node) => {
 	const value = climbTransparent(node);
-	return value.parent != null && isNamedVariable(value.parent, value);
+	return Option.exists(parentOf(value), (parent) => isNamedVariable(parent, value));
 };
+const isNamedFunctionDeclarationBody = (block) => block.type === "BlockStatement" && Option.exists(parentOf(block), (fn) => fn.type === "FunctionDeclaration" && Predicate.isNotNull(fn.id));
 const isNamedFunctionBoundary = (node) => {
 	const parent = node.parent;
-	if (parent?.type === "ArrowFunctionExpression" && parent.body === node) return parent.parent != null && isNamedVariable(parent.parent, parent);
+	if (parent?.type === "ArrowFunctionExpression" && parent.body === node) return Option.exists(parentOf(parent), (declarator) => isNamedVariable(declarator, parent));
 	if (parent?.type !== "ReturnStatement" || parent.argument !== node) return false;
-	const block = parent.parent;
-	const fn = block?.parent;
-	return block?.type === "BlockStatement" && fn?.type === "FunctionDeclaration" && fn.id !== null;
+	return Option.exists(parentOf(parent), isNamedFunctionDeclarationBody);
 };
 const isEffectPromiseCall = (node) => {
 	if (node.type !== "CallExpression") return false;
 	const callee = node.callee;
 	if (callee.type !== "MemberExpression" || callee.computed) return false;
-	return identifierName(callee.object) === "Effect" && ["promise", "tryPromise"].includes(identifierName(callee.property) ?? "");
+	return isIdentifierNamed(callee.object, "Effect") && Option.exists(identifierName(callee.property), (name) => ["promise", "tryPromise"].includes(name));
 };
 const isEffectPromiseBoundary = (node) => {
 	const callback = node.parent;
 	if (callback?.type !== "ArrowFunctionExpression" || callback.body !== node) return false;
-	const call = callback.parent;
-	return call != null && isEffectPromiseCall(call);
+	return Option.exists(parentOf(callback), isEffectPromiseCall);
 };
 const isNamedLazyBoundary = (node) => {
 	return isNamedDirectBinding(node) || isNamedFunctionBoundary(node) || isEffectPromiseBoundary(node);
 };
 const dynamicRequireMessage = (callee) => {
-	if (identifierName(callee) === "require") return "Avoid require(). Use a static import.";
-	if (callee?.type !== "MemberExpression") return void 0;
-	return identifierName(callee.object) === "module" && identifierName(callee.property) === "require" ? "Avoid module.require(). Use a static import." : void 0;
+	if (isIdentifierNamed(callee, "require")) return Option.some("Avoid require(). Use a static import.");
+	if (callee.type !== "MemberExpression") return Option.none();
+	if (isIdentifierNamed(callee.object, "module") && isIdentifierNamed(callee.property, "require")) return Option.some("Avoid module.require(). Use a static import.");
+	return Option.none();
 };
 const noDynamicImports = define({
 	name: "no-dynamic-imports",
@@ -78,7 +87,7 @@ const noDynamicImports = define({
 				onNone: () => Effect.void,
 				onSome: (declaration) => {
 					if (!["module", "node:module"].includes(importSource(declaration))) return Effect.void;
-					for (const specifier of declaration.specifiers) if (specifier.type === "ImportSpecifier" && identifierName(specifier.imported) === "createRequire") createRequireNames.add(specifier.local.name);
+					for (const specifier of declaration.specifiers) if (specifier.type === "ImportSpecifier" && isIdentifierNamed(specifier.imported, "createRequire")) createRequireNames.add(specifier.local.name);
 					return Effect.void;
 				}
 			}),
@@ -94,21 +103,20 @@ const noDynamicImports = define({
 			}),
 			ImportExpression: (node) => Option.match(narrow(node, "ImportExpression"), {
 				onNone: () => Effect.void,
-				onSome: (importExpression) => isNamedLazyBoundary(importExpression) ? Effect.void : ctx.report(make({
-					node,
-					message: "Avoid inline dynamic imports. Bind the imported module or a lazy loader to a descriptive name before using it."
-				}))
+				onSome: (importExpression) => {
+					if (isNamedLazyBoundary(importExpression)) return Effect.void;
+					return report(node, "Avoid inline dynamic imports. Bind the imported module or a lazy loader to a descriptive name before using it.");
+				}
 			}),
 			CallExpression: (node) => {
 				return Option.match(narrow(node, "CallExpression"), {
 					onNone: () => Effect.void,
 					onSome: (call) => {
-						const calleeName = identifierName(call.callee);
-						const message = calleeName !== void 0 && requireAliases.has(calleeName) ? "Avoid createRequire aliases. Keep module loading static." : dynamicRequireMessage(call.callee);
-						return message === void 0 ? Effect.void : ctx.report(make({
-							node: call,
-							message
-						}));
+						const aliasMessage = Option.map(Option.filter(identifierName(call.callee), (name) => requireAliases.has(name)), () => "Avoid createRequire aliases. Keep module loading static.");
+						return Option.match(Option.orElse(aliasMessage, () => dynamicRequireMessage(call.callee)), {
+							onNone: () => Effect.void,
+							onSome: (message) => report(call, message)
+						});
 					}
 				});
 			}

package/dist/rules/no-eager-acquire.js

@@ -3,8 +3,12 @@ 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 { ancestors } from "./_ast-ancestors.js";
+import { expressionArgument } from "./_call-arguments.js";
 import { importedNamespaces, isStaticCall, 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-eager-acquire.ts
 const unwrapExpression = (node) => {
@@ -13,21 +17,19 @@ const unwrapExpression = (node) => {
 	return current;
 };
 const isWithin = (node, ancestor) => {
-	let current = node;
-	while (current !== null) {
-		if (current === ancestor) return true;
-		current = current.parent;
-	}
+	if (node === ancestor) return true;
+	for (const current of ancestors(node)) if (current === ancestor) return true;
 	return false;
 };
+const isThunk = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+/** The value a thunk returns, when its body is an expression or holds exactly one return. */
 const singleReturnedValue = (thunk) => {
 	const body = thunk.body;
-	if (body === null) return void 0;
-	if (body.type !== "BlockStatement") return body;
+	if (Predicate.isNull(body)) return Option.none();
+	if (body.type !== "BlockStatement") return Option.some(body);
 	const returns = body.body.filter((statement) => statement.type === "ReturnStatement");
-	const [returned] = returns;
-	if (returns.length !== 1 || returned === void 0) return void 0;
-	return returned.argument ?? void 0;
+	if (returns.length !== 1) return Option.none();
+	return Option.flatMap(Arr.head(returns), (returned) => Option.fromNullOr(returned.argument));
 };
 const noEagerAcquire = define({
 	name: "no-eager-acquire",
@@ -46,26 +48,27 @@ const noEagerAcquire = define({
 			if (value.type !== "Identifier") return false;
 			return Option.match(findVariableUp(ctx.sourceCode.getScope(value), value.name), {
 				onNone: () => true,
-				onSome: (variable) => {
-					const [definition] = variable.defs;
-					if (definition === void 0) return true;
-					if (seen.has(definition.node)) return false;
-					seen.add(definition.node);
-					if (!isWithin(definition.node, thunk)) return true;
-					if (definition.node.type === "VariableDeclarator") return definition.node.init !== null && isCaptured(definition.node.init, thunk, seen);
-					const defaulted = thunk.params.find((parameter) => parameter.type === "AssignmentPattern" && parameter.left.type === "Identifier" && parameter.left.name === value.name);
-					return defaulted !== void 0 && isCaptured(defaulted.right, thunk, seen);
-				}
+				onSome: (variable) => Option.match(Arr.head(variable.defs), {
+					onNone: () => true,
+					onSome: (definition) => isCapturedDefinition(definition.node, value.name, thunk, seen)
+				})
 			});
 		};
+		/** Whether a binding's definition holds a value that exists before the thunk runs. */
+		const isCapturedDefinition = (definition, name, thunk, seen) => {
+			if (seen.has(definition)) return false;
+			seen.add(definition);
+			if (!isWithin(definition, thunk)) return true;
+			if (definition.type === "VariableDeclarator") {
+				const init = definition.init;
+				return Predicate.isNotNull(init) && isCaptured(init, thunk, seen);
+			}
+			return Option.exists(Arr.findFirst(thunk.params, (parameter) => parameter.type === "AssignmentPattern" && parameter.left.type === "Identifier" && parameter.left.name === name), (defaulted) => isCaptured(defaulted.right, thunk, seen));
+		};
 		const returnsCapturedHandle = (expression, effects) => {
 			if (!isStaticCall(expression, effects, "sync")) return false;
-			const [argument] = expression.arguments;
-			if (argument === void 0 || argument.type === "SpreadElement") return false;
-			const thunk = unwrapExpression(argument);
-			if (thunk.type !== "ArrowFunctionExpression" && thunk.type !== "FunctionExpression") return false;
-			const returned = singleReturnedValue(thunk);
-			return returned !== void 0 && isCaptured(returned, thunk, /* @__PURE__ */ new Set());
+			const thunk = Option.filter(Option.map(expressionArgument(expression, 0), unwrapExpression), isThunk);
+			return Option.exists(thunk, (lazy) => Option.exists(singleReturnedValue(lazy), (returned) => isCaptured(returned, lazy, /* @__PURE__ */ new Set())));
 		};
 		return {
 			ImportDeclaration: (node) => {
@@ -76,14 +79,17 @@ const noEagerAcquire = define({
 				if (node.callee.type === "Super") return Effect.void;
 				const effects = visibleNamespaces(ctx, node, effectNamespaces);
 				if (!isStaticCall(node, effects, "acquireRelease")) return Effect.void;
-				const [acquire] = node.arguments;
-				if (acquire === void 0 || acquire.type === "SpreadElement") return Effect.void;
-				const expression = unwrapExpression(acquire);
-				if (!isStaticCall(expression, effects, "succeed") && !returnsCapturedHandle(expression, effects)) return Effect.void;
-				return ctx.report(make({
-					node: acquire,
-					message: "Build the resource inside acquire (Effect.sync(() => new Resource()), Effect.tryPromise, or another lazy Effect). Effect.succeed(handle) or Effect.sync(() => handle) creates it before acquire runs, so an interruption in between leaks it."
-				}));
+				const eagerAcquire = Option.filter(expressionArgument(node, 0), (acquire) => {
+					const expression = unwrapExpression(acquire);
+					return isStaticCall(expression, effects, "succeed") || returnsCapturedHandle(expression, effects);
+				});
+				return Option.match(eagerAcquire, {
+					onNone: () => Effect.void,
+					onSome: (acquire) => ctx.report(make({
+						node: acquire,
+						message: "Build the resource inside acquire (Effect.sync(() => new Resource()), Effect.tryPromise, or another lazy Effect). Effect.succeed(handle) or Effect.sync(() => handle) creates it before acquire runs, so an interruption in between leaks it."
+					}))
+				});
 			}
 		};
 	}

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

@@ -4,6 +4,8 @@ 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 Arr from "effect/Array";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-effect-run-in-tests.ts
 const effectRunners = [
@@ -32,9 +34,9 @@ const noEffectRunInTests = define({
 		const effectNamespaces = new Set(["Effect"]);
 		const managedRuntimeNamespaces = new Set(["ManagedRuntime"]);
 		const runnerName = (node) => {
-			if (isStaticMember(node, visibleNamespaces(ctx, node, managedRuntimeNamespaces), "make")) return "ManagedRuntime.make";
+			if (isStaticMember(node, visibleNamespaces(ctx, node, managedRuntimeNamespaces), "make")) return Option.some("ManagedRuntime.make");
 			const effects = visibleNamespaces(ctx, node, effectNamespaces);
-			return effectRunners.find((runner) => isStaticMember(node, effects, runner));
+			return Arr.findFirst(effectRunners, (runner) => isStaticMember(node, effects, runner));
 		};
 		return {
 			ImportDeclaration: (node) => {
@@ -43,12 +45,13 @@ const noEffectRunInTests = define({
 				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.`
-				}));
+				return Option.match(runnerName(node), {
+					onNone: () => Effect.void,
+					onSome: (runner) => 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.`
+					}))
+				});
 			}
 		};
 	}