oxlint-plugin-effect 0.9.0 → 0.11.0

package/dist/rules/no-run-collect-on-unbounded-stream.js

@@ -0,0 +1,81 @@
+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 * as Effect from "effect/Effect";
+//#region src/rules/no-run-collect-on-unbounded-stream.ts
+const unboundedSources = new Set([
+	"fromPubSub",
+	"fromPubSubTake",
+	"fromQueue",
+	"repeat"
+]);
+const collectOperations = new Set(["runCollect"]);
+const terminatingOperations = new Set([
+	"take",
+	"takeUntil",
+	"takeUntilEffect",
+	"takeWhile",
+	"takeWhileEffect",
+	"timeout",
+	"timeoutOrElse"
+]);
+const staticOperation = (node, streamNamespaces, operations) => {
+	if (node.type === "SpreadElement") return false;
+	const candidate = node.type === "CallExpression" && node.callee.type !== "Super" ? node.callee : node;
+	for (const operation of operations) if (isStaticMember(candidate, streamNamespaces, operation)) return true;
+	return false;
+};
+const unboundedRoot = (node, streamNamespaces) => {
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
+	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return node;
+	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
+	const root = unboundedRoot(node.callee.object, streamNamespaces);
+	if (root === void 0) return void 0;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
+	return root;
+};
+const collectedSource = (node, streamNamespaces) => {
+	if (node.callee.type === "Super") return void 0;
+	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) {
+		const source = node.arguments[0];
+		if (source !== void 0 && source.type !== "SpreadElement") return source;
+		return;
+	}
+	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, collectOperations)) return node.callee.object;
+};
+const noRunCollectOnUnboundedStream = define({
+	name: "no-run-collect-on-unbounded-stream",
+	meta: meta({
+		type: "problem",
+		description: "Do not collect a clearly unbounded Stream without a terminating operation."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const streamNamespaces = new Set(["Stream"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Stream", "effect/Stream")) streamNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, streamNamespaces);
+				const source = collectedSource(node, namespaces);
+				if (source === void 0) return Effect.void;
+				const root = unboundedRoot(source, namespaces);
+				if (root === void 0) return Effect.void;
+				return ctx.report(make({
+					node: root,
+					message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noRunCollectOnUnboundedStream };

package/dist/rules/no-sequential-effect-all.d.ts

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

package/dist/rules/no-sequential-effect-all.js

@@ -0,0 +1,61 @@
+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 * as Effect from "effect/Effect";
+//#region src/rules/no-sequential-effect-all.ts
+const propertyLiteral = (node, name) => {
+	if (node?.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if ((property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) && property.value.type === "Literal") {
+			const value = property.value.value;
+			if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+		}
+	}
+};
+const pipedToAsVoid = (node, effectNamespaces) => {
+	const member = node.parent;
+	if (member?.type !== "MemberExpression" || member.object !== node || member.computed || member.property.type !== "Identifier" || member.property.name !== "pipe") return false;
+	const pipe = member.parent;
+	if (pipe?.type !== "CallExpression") return false;
+	for (const operation of pipe.arguments) {
+		if (operation.type === "SpreadElement") continue;
+		if (isStaticMember(operation, effectNamespaces, "asVoid")) return true;
+	}
+	return false;
+};
+const noSequentialEffectAll = define({
+	name: "no-sequential-effect-all",
+	meta: meta({
+		type: "suggestion",
+		description: "Use explicit sequencing instead of a serial Effect.all whose result is discarded."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "all")) return Effect.void;
+				if (node.arguments[0]?.type !== "ArrayExpression") return Effect.void;
+				const options = node.arguments[1];
+				if (propertyLiteral(options, "concurrency") !== 1) return Effect.void;
+				if (!(propertyLiteral(options, "discard") === true || pipedToAsVoid(node, namespaces))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Use Effect.andThen or one flat generator for sequential steps. Reserve Effect.all for value aggregation or real concurrency."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noSequentialEffectAll };

package/dist/rules/no-silent-catch-all.d.ts

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

package/dist/rules/no-silent-catch-all.js

@@ -0,0 +1,51 @@
+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 * as Effect from "effect/Effect";
+//#region src/rules/no-silent-catch-all.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isEffectVoid = (node, effectNamespaces) => isStaticMember(node, effectNamespaces, "void");
+const silentlyReturnsVoid = (node, effectNamespaces) => {
+	if (node.params.length !== 0 || node.body === null) return false;
+	if (node.body.type !== "BlockStatement") return isEffectVoid(node.body, effectNamespaces);
+	if (node.body.body.length !== 1) return false;
+	const statement = node.body.body[0];
+	return statement?.type === "ReturnStatement" && statement.argument !== null && isEffectVoid(statement.argument, effectNamespaces);
+};
+const handlerArgument = (node) => {
+	if (node.arguments.length === 1) return node.arguments[0];
+	return node.arguments[1];
+};
+const noSilentCatchAll = define({
+	name: "no-silent-catch-all",
+	meta: meta({
+		type: "problem",
+		description: "Do not silently erase every failure with Effect.void."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!(isStaticMember(node.callee, namespaces, "catchAll") || isStaticMember(node.callee, namespaces, "catchAllCause"))) return Effect.void;
+				const handler = handlerArgument(node);
+				if (!isFunction(handler) || !silentlyReturnsVoid(handler, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node: handler,
+					message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noSilentCatchAll };

package/dist/rules/no-unbounded-concurrency.d.ts

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

package/dist/rules/no-unbounded-concurrency.js

@@ -0,0 +1,50 @@
+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 * as Effect from "effect/Effect";
+//#region src/rules/no-unbounded-concurrency.ts
+const unboundedConcurrency = (node) => {
+	if (node?.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (!(property.key.type === "Identifier" && property.key.name === "concurrency" || property.key.type === "Literal" && property.key.value === "concurrency")) continue;
+		if (property.value.type === "Literal" && property.value.value === "unbounded") return property.value;
+	}
+};
+const fixedCollection = (node) => node?.type === "ArrayExpression" || node?.type === "ObjectExpression";
+const noUnboundedConcurrency = define({
+	name: "no-unbounded-concurrency",
+	meta: meta({
+		type: "problem",
+		description: "Require finite concurrency for Effect operations over collections that can grow."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				let optionsIndex;
+				if (isStaticMember(node.callee, namespaces, "all")) optionsIndex = 1;
+				if (isStaticMember(node.callee, namespaces, "forEach")) optionsIndex = 2;
+				if (optionsIndex === void 0 || fixedCollection(node.arguments[0])) return Effect.void;
+				const unbounded = unboundedConcurrency(node.arguments[optionsIndex]);
+				if (unbounded === void 0) return Effect.void;
+				return ctx.report(make({
+					node: unbounded,
+					message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noUnboundedConcurrency };

package/dist/rules/no-unbounded-retry.d.ts

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

package/dist/rules/no-unbounded-retry.js

@@ -0,0 +1,114 @@
+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, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unbounded-retry.ts
+const unboundedConstructors = new Set([
+	"exponential",
+	"fibonacci",
+	"spaced"
+]);
+const boundedCombinators = new Set(["take"]);
+const staticPropertyName = (node) => {
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return;
+	return node.property.name;
+};
+const hasOwnProperty = (node, name) => {
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (property.key.type === "Identifier" && property.key.name === name) return true;
+		if (property.key.type === "Literal" && property.key.value === name) return true;
+	}
+	return false;
+};
+const propertyValue = (node, name) => {
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) return property.value;
+	}
+};
+const isBoundedOperation = (node, scheduleNamespaces) => {
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
+	const property = staticPropertyName(node.callee);
+	if (property === void 0) return false;
+	if (boundedCombinators.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return true;
+	if (!isStaticMember(node.callee, scheduleNamespaces, "both")) return false;
+	const bound = node.arguments[0];
+	return bound !== void 0 && bound.type !== "SpreadElement" && isStaticCall(bound, scheduleNamespaces, "recurs");
+};
+const unboundedSchedule = (node, scheduleNamespaces) => {
+	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return node;
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
+	const property = staticPropertyName(node.callee);
+	if (property !== void 0 && unboundedConstructors.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return node;
+	if (property !== "pipe" || node.callee.type !== "MemberExpression") return void 0;
+	const root = unboundedSchedule(node.callee.object, scheduleNamespaces);
+	if (root === void 0) return void 0;
+	for (const operation of node.arguments) if (isBoundedOperation(operation, scheduleNamespaces)) return void 0;
+	return root;
+};
+const retryPolicy = (node, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
+	if (node.callee.type === "Super") return void 0;
+	let policyIndex;
+	if (isStaticMember(node.callee, effectNamespaces, "retry")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, effectNamespaces, "retryOrElse")) {
+		if (node.arguments.length === 2) policyIndex = 0;
+		if (node.arguments.length >= 3) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, streamNamespaces, "retry")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, httpClientNamespaces, "retryTransient")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (policyIndex === void 0) return void 0;
+	const policy = node.arguments[policyIndex];
+	if (policy?.type === "SpreadElement") return void 0;
+	if (policy?.type !== "ObjectExpression") return policy;
+	if (hasOwnProperty(policy, "times")) return void 0;
+	return propertyValue(policy, "schedule");
+};
+const noUnboundedRetry = define({
+	name: "no-unbounded-retry",
+	meta: meta({
+		type: "problem",
+		description: "Require retry policies to have an explicit attempt or duration bound."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const httpClientNamespaces = new Set(["HttpClient"]);
+		const scheduleNamespaces = new Set(["Schedule"]);
+		const streamNamespaces = new Set(["Stream"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "HttpClient", "effect/unstable/http/HttpClient")) httpClientNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Schedule", "effect/Schedule")) scheduleNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Stream", "effect/Stream")) streamNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const policy = retryPolicy(node, visibleNamespaces(ctx, node, effectNamespaces), visibleNamespaces(ctx, node, streamNamespaces), visibleNamespaces(ctx, node, httpClientNamespaces));
+				if (policy === void 0) return Effect.void;
+				const unbounded = unboundedSchedule(policy, visibleNamespaces(ctx, node, scheduleNamespaces));
+				if (unbounded === void 0) return Effect.void;
+				return ctx.report(make({
+					node: unbounded,
+					message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noUnboundedRetry };

package/dist/rules/prefer-catch-tag.js

@@ -2,7 +2,7 @@ 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 { isEffectCall, tagComparisonsInOr } from "./_tagged-control-flow.js";
+import { isEffectCall, tagComparisonsInOr, taggedSwitchSubject } from "./_tagged-control-flow.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-catch-tag.ts
 const returnedExpression = (fn) => {
@@ -23,6 +23,32 @@ const hasManualTagPredicate = (argument) => {
 	if (comparisons === null || comparisons.length === 0) return false;
 	return comparisons.every((comparison) => comparison.subject === parameter.name);
 };
+const isFunction = (argument) => argument?.type === "ArrowFunctionExpression" || argument?.type === "FunctionExpression";
+const hasTagCondition = (node, parameter) => {
+	const comparisons = tagComparisonsInOr(node.test);
+	if (comparisons === null || comparisons.length === 0) return false;
+	return comparisons.every((comparison) => comparison.subject === parameter);
+};
+const hasTagSwitch = (node, parameter) => {
+	if (taggedSwitchSubject(node) !== parameter) return false;
+	return node.cases.some((switchCase) => switchCase.test?.type === "Literal" && typeof switchCase.test.value === "string");
+};
+const hasManualTagDispatch = (argument) => {
+	if (!isFunction(argument) || argument.body?.type !== "BlockStatement") return false;
+	const parameter = argument.params[0];
+	if (parameter?.type !== "Identifier") return false;
+	return argument.body.body.some((statement) => {
+		if (statement.type === "IfStatement") return hasTagCondition(statement, parameter.name);
+		if (statement.type === "SwitchStatement") return hasTagSwitch(statement, parameter.name);
+		return false;
+	});
+};
+const catchAllHandler = (node) => {
+	if (!isEffectCall(node, "catchAll")) return void 0;
+	let handlerIndex = 1;
+	if (node.arguments.length === 1) handlerIndex = 0;
+	return node.arguments[handlerIndex];
+};
 const preferCatchTag = define({
 	name: "prefer-catch-tag",
 	meta: meta({
@@ -32,11 +58,12 @@ const preferCatchTag = define({
 	create: function* () {
 		const context = yield* RuleContext;
 		return { CallExpression: (node) => {
-			if (!isEffectCall(node, "catchIf")) return Effect.void;
-			let predicateIndex = 1;
-			if (node.arguments.length === 2) predicateIndex = 0;
-			const predicate = node.arguments[predicateIndex];
-			if (!hasManualTagPredicate(predicate)) return Effect.void;
+			if (isEffectCall(node, "catchIf")) {
+				let predicateIndex = 1;
+				if (node.arguments.length === 2) predicateIndex = 0;
+				const predicate = node.arguments[predicateIndex];
+				if (!hasManualTagPredicate(predicate)) return Effect.void;
+			} else if (!hasManualTagDispatch(catchAllHandler(node))) return Effect.void;
 			return context.report(make({
 				node,
 				message: "Use Effect.catchTag for one tagged failure or Effect.catchTags for multiple tagged failures."

package/dist/rules/prefer-match-tags-exhaustive.js

@@ -2,7 +2,7 @@ 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 { isInsideCatchAllHandler, taggedSwitchSubject } from "./_tagged-control-flow.js";
+import { isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-match-tags-exhaustive.ts
 const statementReturns = (statement) => {
@@ -25,6 +25,51 @@ const isCompleteTransformationShape = (node) => {
 	}
 	return true;
 };
+const isElseIf = (node) => node.parent?.type === "IfStatement" && node.parent.alternate === node;
+const isTerminalStatement = (node) => {
+	if (node.parent?.type !== "BlockStatement") return true;
+	return node.parent.body.at(-1) === node;
+};
+const isCompleteIfTransformationShape = (node) => {
+	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+	let current = node;
+	let subject;
+	const tags = /* @__PURE__ */ new Set();
+	let branchCount = 0;
+	while (true) {
+		const comparison = tagComparison(current.test);
+		if (comparison === null || !statementReturns(current.consequent)) return false;
+		if (subject !== void 0 && comparison.subject !== subject) return false;
+		if (tags.has(comparison.tag)) return false;
+		subject = comparison.subject;
+		tags.add(comparison.tag);
+		branchCount += 1;
+		if (current.alternate === null) break;
+		if (current.alternate.type !== "IfStatement") return false;
+		current = current.alternate;
+	}
+	return branchCount >= 2;
+};
+const isCompleteSequentialIfTransformationShape = (node) => {
+	if (node.alternate !== null || node.parent?.type !== "BlockStatement") return false;
+	const statements = node.parent.body;
+	const index = statements.indexOf(node);
+	if (index < 0) return false;
+	const comparison = tagComparison(node.test);
+	if (comparison === null || !statementReturns(node.consequent)) return false;
+	const previous = statements[index - 1];
+	if (previous?.type === "IfStatement" && previous.alternate === null) {
+		if (tagComparison(previous.test)?.subject === comparison.subject && statementReturns(previous.consequent)) return false;
+	}
+	const tags = new Set([comparison.tag]);
+	for (const statement of statements.slice(index + 1)) {
+		if (statement.type !== "IfStatement" || statement.alternate !== null) return false;
+		const next = tagComparison(statement.test);
+		if (next === null || next.subject !== comparison.subject || tags.has(next.tag) || !statementReturns(statement.consequent)) return false;
+		tags.add(next.tag);
+	}
+	return tags.size >= 2;
+};
 const preferMatchTagsExhaustive = define({
 	name: "prefer-match-tags-exhaustive",
 	meta: meta({
@@ -33,13 +78,22 @@ const preferMatchTagsExhaustive = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { SwitchStatement: (node) => {
-			if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
-			return context.report(make({
-				node,
-				message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
-			}));
-		} };
+		return {
+			SwitchStatement: (node) => {
+				if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				return context.report(make({
+					node,
+					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
+				}));
+			},
+			IfStatement: (node) => {
+				if (!isCompleteIfTransformationShape(node) && !isCompleteSequentialIfTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				return context.report(make({
+					node,
+					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new branch."
+				}));
+			}
+		};
 	}
 });
 //#endregion

package/dist/rules/prefer-service-of.d.ts

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

package/dist/rules/prefer-service-of.js

@@ -0,0 +1,65 @@
+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, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/prefer-service-of.ts
+const returnedObject = (node) => {
+	if (node?.type !== "ArrowFunctionExpression" && node?.type !== "FunctionExpression") return;
+	if (node.body === null) return void 0;
+	if (node.body.type === "ObjectExpression") return node.body;
+	if (node.body.type !== "BlockStatement") return void 0;
+	for (const statement of node.body.body) if (statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression") return statement.argument;
+};
+const implementationObject = (node, layerNamespaces, effectNamespaces) => {
+	if (node.callee.type === "Super" || node.arguments.length < 2) return void 0;
+	const implementation = node.arguments[1];
+	if (implementation === void 0 || implementation.type === "SpreadElement") return void 0;
+	if (isStaticMember(node.callee, layerNamespaces, "succeed")) {
+		if (implementation.type === "ObjectExpression") return implementation;
+		return;
+	}
+	if (isStaticMember(node.callee, layerNamespaces, "sync")) return returnedObject(implementation);
+	if (!isStaticMember(node.callee, layerNamespaces, "effect")) return void 0;
+	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return;
+	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) {
+		const value = implementation.arguments[0];
+		if (value?.type === "ObjectExpression") return value;
+		return;
+	}
+	if (isStaticCall(implementation, effectNamespaces, "gen")) return returnedObject(implementation.arguments[0]);
+};
+const preferServiceOf = define({
+	name: "prefer-service-of",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Service.of to check inline Layer implementations against the service interface."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const layerNamespaces = new Set(["Layer"]);
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Layer", "effect/Layer")) layerNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const service = node.arguments[0];
+				if (service?.type !== "Identifier") return Effect.void;
+				const implementation = implementationObject(node, visibleNamespaces(ctx, node, layerNamespaces), visibleNamespaces(ctx, node, effectNamespaces));
+				if (implementation === void 0) return Effect.void;
+				return ctx.report(make({
+					node: implementation,
+					message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { preferServiceOf };

package/dist/rules/require-named-effect-fn.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/require-named-effect-fn.d.ts
+declare const requireNamedEffectFn: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { requireNamedEffectFn };