oxlint-plugin-effect 0.13.0 → 0.14.0

package/dist/rules/_anti-slop-type-alias-resolution.js

@@ -0,0 +1,146 @@
+import { lexicalTypeParameterNames } from "./_anti-slop-lexical-type-parameters.js";
+//#region src/rules/_anti-slop-type-alias-resolution.ts
+const environmentsByProgram = /* @__PURE__ */ new WeakMap();
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function enclosingTypeScope(node) {
+	let current = node.parent;
+	while (current !== null) {
+		if (current.type === "Program" || current.type === "BlockStatement" || current.type === "TSModuleBlock" || current.type === "StaticBlock" || current.type === "SwitchStatement") return current;
+		current = current.parent;
+	}
+	return node;
+}
+function declaredTypeBinding(node) {
+	if (node.type === "TSTypeAliasDeclaration") return {
+		alias: node,
+		name: node.id.name
+	};
+	if (node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return node.id === null ? null : {
+		alias: null,
+		name: node.id.name
+	};
+	if (node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") return {
+		alias: null,
+		name: node.local.name
+	};
+	return null;
+}
+function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
+	const declared = declaredTypeBinding(node);
+	if (declared !== null) {
+		const bindings = bindingsByName.get(declared.name) ?? [];
+		bindings.push({
+			...declared,
+			scope: enclosingTypeScope(node)
+		});
+		bindingsByName.set(declared.name, bindings);
+		if (declared.alias !== null) aliases.push(declared.alias);
+	}
+	const fields = node;
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = fields[key];
+		if (isNode(value)) {
+			collectTypeBindings(value, visitorKeys, bindingsByName, aliases);
+			continue;
+		}
+		if (!Array.isArray(value)) continue;
+		for (const child of value) if (isNode(child)) collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+	}
+}
+/** Collect every lexical type alias and competing type binding in a program. */
+function createTypeAliasEnvironment(program, visitorKeys) {
+	const cached = environmentsByProgram.get(program);
+	if (cached !== void 0) return cached;
+	const bindingsByName = /* @__PURE__ */ new Map();
+	const aliases = [];
+	collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
+	const environment = {
+		aliases,
+		bindingsByName,
+		visitorKeys
+	};
+	environmentsByProgram.set(program, environment);
+	return environment;
+}
+function ancestorDistance(ancestor, node) {
+	let current = node;
+	let distance = 0;
+	while (current !== null) {
+		if (current === ancestor) return distance;
+		current = current.parent;
+		distance += 1;
+	}
+	return null;
+}
+function nearestTypeBindings(name, use, environment) {
+	const candidates = environment.bindingsByName.get(name) ?? [];
+	let nearestDistance = Number.POSITIVE_INFINITY;
+	let nearest = [];
+	for (const candidate of candidates) {
+		const distance = ancestorDistance(candidate.scope, use);
+		if (distance === null || distance > nearestDistance) continue;
+		if (distance === nearestDistance) {
+			nearest.push(candidate);
+			continue;
+		}
+		nearestDistance = distance;
+		nearest = [candidate];
+	}
+	return nearest;
+}
+/** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
+function visibleTypeAlias(name, use, environment) {
+	if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name)) return null;
+	const bindings = nearestTypeBindings(name, use, environment);
+	return bindings.length === 1 ? bindings[0]?.alias ?? null : null;
+}
+/** Return whether a local declaration shadows a built-in type at this use. */
+function hasVisibleTypeBinding(name, use, environment) {
+	return lexicalTypeParameterNames(use, environment.visitorKeys).has(name) || nearestTypeBindings(name, use, environment).length > 0;
+}
+function typeReferenceName(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function aliasSubstitutions(alias, reference, base) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const typeArguments = reference.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const explicitArgument = typeArguments[index];
+		const argument = explicitArgument ?? parameter.default;
+		if (argument === null || argument === void 0) return null;
+		const argumentSubstitutions = explicitArgument === void 0 ? next : base;
+		next.set(parameter.name.name, {
+			type: argument,
+			substitutions: new Map(argumentSubstitutions)
+		});
+	}
+	return next;
+}
+/** Match a type after resolving visible aliases and substituting their type parameters. */
+function resolvedTypeMatches(type, environment, matcher) {
+	const evaluate = (current, substitutions, resolvingAliases) => {
+		if (current.type === "TSTypeReference") {
+			const name = typeReferenceName(current);
+			if (name !== null) {
+				const substitution = substitutions.get(name);
+				if (substitution !== void 0 && !current.typeArguments?.params.length) return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
+				const alias = visibleTypeAlias(name, current, environment);
+				if (alias !== null && !resolvingAliases.has(alias)) {
+					const nextSubstitutions = aliasSubstitutions(alias, current, substitutions);
+					if (nextSubstitutions !== null) {
+						const nextResolving = new Set(resolvingAliases);
+						nextResolving.add(alias);
+						return evaluate(alias.typeAnnotation, nextSubstitutions, nextResolving);
+					}
+				}
+			}
+		}
+		return matcher(current, (child) => evaluate(child, substitutions, resolvingAliases));
+	};
+	return evaluate(type, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+}
+//#endregion
+export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };

package/dist/rules/_function-metrics.js

@@ -154,36 +154,36 @@ const templateOperand = (node) => {
 	return typeof raw === "string" && raw.length > 0 ? raw : null;
 };
 /** Node types that always stand for the same operator tokens. */
-const fixedOperators = {
-	ForStatement: ["for"],
-	ForInStatement: ["for-in"],
-	WhileStatement: ["while"],
-	DoWhileStatement: ["do-while"],
-	SwitchStatement: ["switch"],
-	ReturnStatement: ["return"],
-	ThrowStatement: ["throw"],
-	CatchClause: ["catch"],
-	BreakStatement: ["break"],
-	ContinueStatement: ["continue"],
-	LabeledStatement: [":"],
-	DebuggerStatement: ["debugger"],
-	WithStatement: ["with"],
-	AssignmentPattern: ["="],
-	NewExpression: ["new"],
-	ArrayExpression: ["[]"],
-	ArrayPattern: ["[]"],
-	ObjectExpression: ["{}"],
-	ObjectPattern: ["{}"],
-	SpreadElement: ["..."],
-	RestElement: ["..."],
-	ConditionalExpression: ["?:"],
-	SequenceExpression: [","],
-	AwaitExpression: ["await"],
-	ImportExpression: ["import()"],
-	TemplateLiteral: ["`"],
-	JSXElement: ["<>"],
-	JSXFragment: ["<>"]
-};
+const fixedOperators = new Map([
+	["ForStatement", ["for"]],
+	["ForInStatement", ["for-in"]],
+	["WhileStatement", ["while"]],
+	["DoWhileStatement", ["do-while"]],
+	["SwitchStatement", ["switch"]],
+	["ReturnStatement", ["return"]],
+	["ThrowStatement", ["throw"]],
+	["CatchClause", ["catch"]],
+	["BreakStatement", ["break"]],
+	["ContinueStatement", ["continue"]],
+	["LabeledStatement", [":"]],
+	["DebuggerStatement", ["debugger"]],
+	["WithStatement", ["with"]],
+	["AssignmentPattern", ["="]],
+	["NewExpression", ["new"]],
+	["ArrayExpression", ["[]"]],
+	["ArrayPattern", ["[]"]],
+	["ObjectExpression", ["{}"]],
+	["ObjectPattern", ["{}"]],
+	["SpreadElement", ["..."]],
+	["RestElement", ["..."]],
+	["ConditionalExpression", ["?:"]],
+	["SequenceExpression", [","]],
+	["AwaitExpression", ["await"]],
+	["ImportExpression", ["import()"]],
+	["TemplateLiteral", ["`"]],
+	["JSXElement", ["<>"]],
+	["JSXFragment", ["<>"]]
+]);
 /** Node types whose operator token carries the operator itself. */
 const operatorCarriers = new Set([
 	"BinaryExpression",
@@ -229,7 +229,7 @@ const expressionOperators = (node) => {
 };
 /** Every operator token a node stands for. */
 const operatorsOf = (node) => [
-	...fixedOperators[node.type] ?? [],
+	...fixedOperators.get(node.type) ?? [],
 	...statementOperators(node),
 	...expressionOperators(node)
 ];

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,6 +23,9 @@ 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";
@@ -31,6 +38,7 @@ 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 +48,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, 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,6 +24,9 @@ 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";
@@ -32,6 +39,7 @@ 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 +49,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,6 +77,9 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noNullish: () => noNullish,
 	noObjectParameters: () => noObjectParameters,
 	noPerCallCacheConstruction: () => noPerCallCacheConstruction,
+	noReduceAccumulatorCopy: () => noReduceAccumulatorCopy,
+	noReflectApply: () => noReflectApply,
+	noReflectGet: () => noReflectGet,
 	noRunCollectOnUnboundedStream: () => noRunCollectOnUnboundedStream,
 	noRuntimeTypeof: () => noRuntimeTypeof,
 	noSequentialEffectAll: () => noSequentialEffectAll,
@@ -76,6 +92,7 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noUnboundedConcurrency: () => noUnboundedConcurrency,
 	noUnboundedRetry: () => noUnboundedRetry,
 	noUnknownParameters: () => noUnknownParameters,
+	noUnknownReturns: () => noUnknownReturns,
 	noUnknownTypeAliases: () => noUnknownTypeAliases,
 	noUnsafeDictionaryType: () => noUnsafeDictionaryType,
 	noWidenThenAssert: () => noWidenThenAssert,
@@ -84,7 +101,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,39 @@
+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 Effect from "effect/Effect";
+//#region src/rules/no-array-filter-map.ts
+/** 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) => {
+			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({
+				node,
+				messageId: "arrayFilterMap",
+				data: {
+					first: inner.name,
+					second: outer.name
+				}
+			}));
+		} };
+	}
+});
+//#endregion
+export { noArrayFilterMap };

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,67 +12,24 @@ 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({
-				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))));
-		} };
+		return { SpreadElement: (node) => node.parent?.type === "ObjectExpression" && isConditionalEmptyObjectSpread(node.argument) ? context.report(fromId({
+			node,
+			messageId: "avoid"
+		})) : Effect.void };
 	}
 });
 //#endregion

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,92 @@
+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 { importedNamespaces, isStaticCall, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Option from "effect/Option";
+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) => {
+	let current = node;
+	while (current !== null) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const singleReturnedValue = (thunk) => {
+	const body = thunk.body;
+	if (body === null) return void 0;
+	if (body.type !== "BlockStatement") return 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;
+};
+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) => {
+					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);
+				}
+			});
+		};
+		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());
+		};
+		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 [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."
+				}));
+			}
+		};
+	}
+});
+//#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 };