oxlint-plugin-effect 0.13.0 → 0.15.0

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/_test-files.js

@@ -0,0 +1,8 @@
+//#region src/rules/_test-files.ts
+/** Test and spec modules: `*.test.*` and `*.spec.*` with a JS or TS extension. */
+const testFilePattern = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+const isTestFile = (filename) => testFilePattern.test(filename);
+/** Visitor for a file a rule does not apply to. */
+const skipFile = {};
+//#endregion
+export { isTestFile, skipFile };

package/dist/rules/index.d.ts

@@ -2,15 +2,19 @@ import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
 import { maxCognitiveComplexity } from "./max-cognitive-complexity.js";
 import { maxHalsteadDifficulty } from "./max-halstead-difficulty.js";
+import { noArrayFilterMap } from "./no-array-filter-map.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
 import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
+import { noEagerAcquire } from "./no-eager-acquire.js";
+import { noEffectRunInTests } from "./no-effect-run-in-tests.js";
 import { noGlobals } from "./no-globals.js";
 import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
 import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
+import { noModuleLevelMutableState } from "./no-module-level-mutable-state.js";
 import { noModuleMocks } from "./no-module-mocks.js";
 import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
@@ -19,18 +23,23 @@ import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
 import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noReduceAccumulatorCopy } from "./no-reduce-accumulator-copy.js";
+import { noReflectApply } from "./no-reflect-apply.js";
+import { noReflectGet } from "./no-reflect-get.js";
 import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
 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";
 import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
 import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
+import { noUnknownReturns } from "./no-unknown-returns.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
 import { noWidenThenAssert } from "./no-widen-then-assert.js";
@@ -40,10 +49,11 @@ import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
 import { preferServiceOf } from "./prefer-service-of.js";
 import { requireNamedEffectFn } from "./require-named-effect-fn.js";
+import { requireSuppressionReason } from "./require-suppression-reason.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { maxCognitiveComplexity, maxHalsteadDifficulty, noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn };
+  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

@@ -3,15 +3,19 @@ import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
 import { maxCognitiveComplexity } from "./max-cognitive-complexity.js";
 import { maxHalsteadDifficulty } from "./max-halstead-difficulty.js";
+import { noArrayFilterMap } from "./no-array-filter-map.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
 import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
+import { noEagerAcquire } from "./no-eager-acquire.js";
+import { noEffectRunInTests } from "./no-effect-run-in-tests.js";
 import { noGlobals } from "./no-globals.js";
 import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
 import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
+import { noModuleLevelMutableState } from "./no-module-level-mutable-state.js";
 import { noModuleMocks } from "./no-module-mocks.js";
 import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
@@ -20,18 +24,23 @@ import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
 import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noReduceAccumulatorCopy } from "./no-reduce-accumulator-copy.js";
+import { noReflectApply } from "./no-reflect-apply.js";
+import { noReflectGet } from "./no-reflect-get.js";
 import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
 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";
 import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
 import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
+import { noUnknownReturns } from "./no-unknown-returns.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
 import { noWidenThenAssert } from "./no-widen-then-assert.js";
@@ -41,21 +50,26 @@ import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
 import { preferServiceOf } from "./prefer-service-of.js";
 import { requireNamedEffectFn } from "./require-named-effect-fn.js";
+import { requireSuppressionReason } from "./require-suppression-reason.js";
 //#region src/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
 	maxCognitiveComplexity: () => maxCognitiveComplexity,
 	maxHalsteadDifficulty: () => maxHalsteadDifficulty,
+	noArrayFilterMap: () => noArrayFilterMap,
 	noAs: () => noAs,
 	noAsyncFunction: () => noAsyncFunction,
 	noChainedTypeAssertions: () => noChainedTypeAssertions,
 	noConditionalEmptyObjectSpread: () => noConditionalEmptyObjectSpread,
 	noDynamicImports: () => noDynamicImports,
+	noEagerAcquire: () => noEagerAcquire,
 	noEffectBind: () => noEffectBind,
 	noEffectDo: () => noEffectDo,
+	noEffectRunInTests: () => noEffectRunInTests,
 	noGlobals: () => noGlobals,
 	noInlineProvide: () => noInlineProvide,
 	noKnownValueWidening: () => noKnownValueWidening,
 	noManagedRuntimeInEffect: () => noManagedRuntimeInEffect,
+	noModuleLevelMutableState: () => noModuleLevelMutableState,
 	noModuleMocks: () => noModuleMocks,
 	noNestedEffectGen: () => noNestedEffectGen,
 	noNewError: () => noNewError,
@@ -64,18 +78,23 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noNullish: () => noNullish,
 	noObjectParameters: () => noObjectParameters,
 	noPerCallCacheConstruction: () => noPerCallCacheConstruction,
+	noReduceAccumulatorCopy: () => noReduceAccumulatorCopy,
+	noReflectApply: () => noReflectApply,
+	noReflectGet: () => noReflectGet,
 	noRunCollectOnUnboundedStream: () => noRunCollectOnUnboundedStream,
 	noRuntimeTypeof: () => noRuntimeTypeof,
 	noSequentialEffectAll: () => noSequentialEffectAll,
 	noShapeInSymbolNames: () => noShapeInSymbolNames,
 	noSilentCatchAll: () => noSilentCatchAll,
 	noTernary: () => noTernary,
+	noTestGlobals: () => noTestGlobals,
 	noTestLifecycleHooks: () => noTestLifecycleHooks,
 	noThrowStatement: () => noThrowStatement,
 	noTryCatch: () => noTryCatch,
 	noUnboundedConcurrency: () => noUnboundedConcurrency,
 	noUnboundedRetry: () => noUnboundedRetry,
 	noUnknownParameters: () => noUnknownParameters,
+	noUnknownReturns: () => noUnknownReturns,
 	noUnknownTypeAliases: () => noUnknownTypeAliases,
 	noUnsafeDictionaryType: () => noUnsafeDictionaryType,
 	noWidenThenAssert: () => noWidenThenAssert,
@@ -84,7 +103,8 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	preferMatchTagsExhaustive: () => preferMatchTagsExhaustive,
 	preferPredicateIsTagged: () => preferPredicateIsTagged,
 	preferServiceOf: () => preferServiceOf,
-	requireNamedEffectFn: () => requireNamedEffectFn
+	requireNamedEffectFn: () => requireNamedEffectFn,
+	requireSuppressionReason: () => requireSuppressionReason
 });
 //#endregion
 export { rules_exports };

package/dist/rules/no-array-filter-map.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-array-filter-map.d.ts
+/** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
+declare const noArrayFilterMap: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noArrayFilterMap };

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

@@ -0,0 +1,49 @@
+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, 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",
+	meta: meta({
+		type: "suggestion",
+		description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation.",
+		messages: { arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { CallExpression: (node) => Option.match(filterMapPair(context.sourceCode, node), {
+			onNone: () => Effect.void,
+			onSome: ({ first, second }) => context.report(fromId({
+				node,
+				messageId: "arrayFilterMap",
+				data: {
+					first,
+					second
+				}
+			}))
+		}) };
+	}
+});
+//#endregion
+export { noArrayFilterMap };

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.d.ts

@@ -1,7 +1,7 @@
 import * as _$_oxlint_plugins0 from "@oxlint/plugins";
 
 //#region src/rules/no-conditional-empty-object-spread.d.ts
-/** Ban conditional empty-object spreads and autofix equivalent direct property declarations. */
+/** Ban conditional empty-object spreads without changing their omission semantics. */
 declare const noConditionalEmptyObjectSpread: _$_oxlint_plugins0.CreateRule;
 //#endregion
 export { noConditionalEmptyObjectSpread };

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

@@ -1,4 +1,4 @@
-import { fromId, replaceText, withFix } from "../vendor/effect-oxlint/Diagnostic.js";
+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";
@@ -12,66 +12,26 @@ function unwrapParentheses(node) {
 function isEmptyObjectExpression(node) {
 	return node.type === "ObjectExpression" && node.properties.length === 0;
 }
-function singleObjectProperty(node) {
-	if (node.type !== "ObjectExpression" || node.properties.length !== 1) return null;
-	const [property] = node.properties;
-	if (property?.type !== "Property" || property.kind !== "init" || property.method || property.computed) return null;
-	return property;
-}
-function conditionalEmptyObjectSpread(node) {
+function isConditionalEmptyObjectSpread(node) {
 	const conditional = unwrapParentheses(node);
-	if (conditional.type !== "ConditionalExpression") return null;
-	if (isEmptyObjectExpression(conditional.consequent)) return {
-		conditional,
-		property: singleObjectProperty(conditional.alternate)
-	};
-	if (isEmptyObjectExpression(conditional.alternate)) return {
-		conditional,
-		property: singleObjectProperty(conditional.consequent)
-	};
-	return null;
-}
-function undefinedCheckedExpression(test) {
-	const binary = unwrapParentheses(test);
-	if (binary.type !== "BinaryExpression") return null;
-	if (binary.operator !== "===" && binary.operator !== "!==") return null;
-	const left = unwrapParentheses(binary.left);
-	const right = unwrapParentheses(binary.right);
-	const leftIsUndefined = left.type === "Identifier" && left.name === "undefined";
-	if (leftIsUndefined === (right.type === "Identifier" && right.name === "undefined")) return null;
-	return {
-		expression: leftIsUndefined ? right : left,
-		isDefinedWhenTrue: binary.operator === "!=="
-	};
-}
-function canAutofixConditionalEmptyObjectSpread(sourceCode, conditional, property) {
-	const checked = undefinedCheckedExpression(conditional.test);
-	if (checked === null) return false;
-	if (conditional.consequent === property.parent !== checked.isDefinedWhenTrue) return false;
-	return sourceCode.getText(unwrapParentheses(checked.expression)) === sourceCode.getText(property.value);
+	return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-/** Ban conditional empty-object spreads and autofix equivalent direct property declarations. */
+/** Ban conditional empty-object spreads without changing their omission semantics. */
 const noConditionalEmptyObjectSpread = define({
 	name: "no-conditional-empty-object-spread",
 	meta: meta({
 		type: "suggestion",
-		fixable: "code",
 		description: "Disallow object spreads that conditionally spread an empty object to omit fields.",
 		messages: { avoid: "Do not use conditional empty-object spreads. Prefer a direct property or build the object in separate statements." }
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
 		return { SpreadElement: (node) => {
-			if (node.parent?.type !== "ObjectExpression") return Effect.void;
-			const match = conditionalEmptyObjectSpread(node.argument);
-			if (match === null) return Effect.void;
-			const { conditional, property } = match;
-			const diagnostic = fromId({
+			if (node.parent?.type !== "ObjectExpression" || !isConditionalEmptyObjectSpread(node.argument)) return Effect.void;
+			return context.report(fromId({
 				node,
 				messageId: "avoid"
-			});
-			if (property === null || !canAutofixConditionalEmptyObjectSpread(context.sourceCode, conditional, property)) return context.report(diagnostic);
-			return context.report(withFix(diagnostic, replaceText(node, context.sourceCode.getText(property))));
+			}));
 		} };
 	}
 });

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.d.ts

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

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

@@ -0,0 +1,98 @@
+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 { 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) => {
+	let current = node;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	return current;
+};
+const isWithin = (node, ancestor) => {
+	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 (Predicate.isNull(body)) return Option.none();
+	if (body.type !== "BlockStatement") return Option.some(body);
+	const returns = body.body.filter((statement) => statement.type === "ReturnStatement");
+	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",
+	meta: meta({
+		type: "problem",
+		description: "Construct a resource inside the Effect.acquireRelease acquire Effect, not before it."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		/** Whether the value was bound outside the thunk, so it exists before acquire runs. */
+		const isCaptured = (expression, thunk, seen) => {
+			const value = unwrapExpression(expression);
+			if (value.type === "ThisExpression") return true;
+			if (value.type === "MemberExpression") return value.object.type !== "Super" && isCaptured(value.object, thunk, seen);
+			if (value.type !== "Identifier") return false;
+			return Option.match(findVariableUp(ctx.sourceCode.getScope(value), value.name), {
+				onNone: () => true,
+				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 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) => {
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.callee.type === "Super") return Effect.void;
+				const effects = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticCall(node, effects, "acquireRelease")) return Effect.void;
+				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."
+					}))
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noEagerAcquire };

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 };