oxlint-plugin-effect 0.13.0 → 0.15.0

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

@@ -0,0 +1,60 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isTestFile, skipFile } from "./_test-files.js";
+import * as 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 = [
+	"runCallback",
+	"runCallbackWith",
+	"runFork",
+	"runForkWith",
+	"runPromise",
+	"runPromiseExit",
+	"runPromiseExitWith",
+	"runPromiseWith",
+	"runSync",
+	"runSyncExit",
+	"runSyncExitWith",
+	"runSyncWith"
+];
+const noEffectRunInTests = define({
+	name: "no-effect-run-in-tests",
+	meta: meta({
+		type: "problem",
+		description: "Run Effects in tests through it.effect or it.layer instead of Effect.run* or ManagedRuntime.make."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFile(ctx.filename)) return skipFile;
+		const effectNamespaces = new Set(["Effect"]);
+		const managedRuntimeNamespaces = new Set(["ManagedRuntime"]);
+		const runnerName = (node) => {
+			if (isStaticMember(node, visibleNamespaces(ctx, node, managedRuntimeNamespaces), "make")) return Option.some("ManagedRuntime.make");
+			const effects = visibleNamespaces(ctx, node, effectNamespaces);
+			return Arr.findFirst(effectRunners, (runner) => isStaticMember(node, effects, runner));
+		};
+		return {
+			ImportDeclaration: (node) => {
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "ManagedRuntime", "effect/ManagedRuntime")) managedRuntimeNamespaces.add(name);
+				return Effect.void;
+			},
+			MemberExpression: (node) => {
+				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.`
+					}))
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noEffectRunInTests };

package/dist/rules/no-globals.js

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

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

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

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

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

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

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

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

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

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

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