@doubleloop-io/oxlint-plugin-effect 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/rules/{no-bare-error-in-effect.js → no-throw-or-primitive-failure.js}

@@ -1,20 +1,28 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, isEffectGenerator, nearestFunction } from "../shared/effect-ast.js";
+import { isTestFile } from "../shared/test-files.js";
 // Only the two forms the effecttsgo preset misses: `Effect.fail(new Error(…))` and
 // `extends Error` are already reported by global-error-in-effect-failure and extends-native-error.
-export const noBareErrorInEffectRule = defineRule({
+export const noThrowOrPrimitiveFailureRule = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Fail Effects with tagged errors, never with a `throw` or a primitive value.",
+            description: "Fail Effects with tagged errors, never with a `throw` or a primitive value. Primitive failures in test files are allowed.",
         },
         messages: {
             throwInGenerator: "A `throw` inside an Effect generator becomes a defect: `return yield* new TaggedError(...)` instead.",
             primitiveFailure: "Fail with a tagged error (`Data.TaggedError` or `Schema.TaggedError`), not a primitive value.",
         },
+        schema: [],
     },
     createOnce(context) {
+        let inTestFile = false;
         return {
+            // A test's synthetic failure (`Effect.fail("boom")`) feeds code generic over the error,
+            // which never discriminates it; a `throw` is still a defect there.
+            before() {
+                inTestFile = isTestFile(context);
+            },
             ThrowStatement(node) {
                 const fn = nearestFunction(node);
                 if (fn !== undefined && isEffectGenerator(fn)) {
@@ -22,7 +30,7 @@ export const noBareErrorInEffectRule = defineRule({
                 }
             },
             CallExpression(node) {
-                if (calleeOf(node, "Effect") !== "fail")
+                if (inTestFile || calleeOf(node, "Effect") !== "fail")
                     return;
                 const [failure] = node.arguments;
                 if (failure?.type === "Literal" || failure?.type === "TemplateLiteral") {

package/dist/rules/no-yielded-match.js

@@ -1,7 +1,12 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, isEffectGenerator, isFunctionNode, memberOf, nearestFunction, } from "../shared/effect-ast.js";
 import { handlersOf, nestedBranches } from "../shared/match-ast.js";
-const guards = { Option: "Option.isNone", Result: "Result.isFailure" };
+// `Either` is the Effect 3 name of `Result`.
+const guards = {
+    Option: "Option.isNone",
+    Result: "Result.isFailure",
+    Either: "Either.isLeft",
+};
 const matchedModule = (node) => {
     if (node?.type !== "CallExpression")
         return undefined;
@@ -9,6 +14,8 @@ const matchedModule = (node) => {
         return "Option";
     if (memberOf(node.callee, "Result") === "match")
         return "Result";
+    if (memberOf(node.callee, "Either") === "match")
+        return "Either";
     return undefined;
 };
 const isPipe = (callee) => (callee.type === "Identifier" && callee.name === "pipe") ||
@@ -58,7 +65,7 @@ export const noYieldedMatchRule = defineRule({
     meta: {
         type: "suggestion",
         docs: {
-            description: "Inside an Effect generator, return early on the empty or failed case instead of yielding an `Option.match`/`Result.match`.",
+            description: "Inside an Effect generator, return early on the empty or failed case instead of yielding a match (`Option.match`; v3: `Either.match`, v4: `Result.match`).",
         },
         messages: {
             yieldedMatch: "This `yield*` of a `{{module}}.match` splits the generator into two branches: return early with `if ({{guard}}(…)) return …` and keep one main path.",

package/dist/rules/prefer-effect-vitest.d.ts

@@ -0,0 +1 @@
+export declare const preferEffectVitestRule: import("@oxlint/plugins").Rule;

package/dist/rules/prefer-effect-vitest.js

@@ -0,0 +1,45 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { runnerName } from "../shared/effect-runners.js";
+import { isTestFile } from "../shared/test-files.js";
+// Without `@effect/vitest` the remedy is out of reach, so the rule stays silent. Not cached:
+// a long-lived linter would miss a later install, and only test files pay for the lookup.
+const isEffectVitestInstalled = (filename) => {
+    for (let dir = dirname(filename);; dir = dirname(dir)) {
+        if (existsSync(join(dir, "node_modules", "@effect", "vitest", "package.json")))
+            return true;
+        if (dirname(dir) === dir)
+            return false;
+    }
+};
+// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
+export const preferEffectVitestRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Run Effects in tests through `@effect/vitest`. Only test files of projects that install it are checked.",
+        },
+        messages: {
+            runInTest: "`{{name}}` runs an Effect program in a test: let `@effect/vitest` run it, so the test gets the test runtime and its fixtures become Layers.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        let checked = false;
+        return {
+            before() {
+                checked =
+                    isTestFile(context) &&
+                        isEffectVitestInstalled(resolve(context.cwd, context.filename));
+            },
+            MemberExpression(node) {
+                if (!checked)
+                    return;
+                const name = runnerName(node);
+                if (name !== undefined)
+                    context.report({ node, messageId: "runInTest", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/provide-named-layer.js

@@ -1,6 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf } from "../shared/effect-ast.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
 import { isTestFile } from "../shared/test-files.js";
 const matchers = new Set(["match", "$match"]);
 // Factories and module members (`planLayer(csv)`, `CsvSheetReader.layer(path)`) are names;
@@ -26,13 +25,7 @@ export const provideNamedLayerRule = defineRule({
         messages: {
             inlineLayer: "Name the layer passed to `Effect.provide` (`const appLayer = Layer.mergeAll(...)`) instead of composing it inline.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;

package/dist/rules/redacted-secret-names.js

@@ -12,15 +12,24 @@ const defaultSecretFields = [
     "refreshToken",
     "idToken",
 ];
-const nullableWrappers = new Set(["optional", "optionalKey", "NullOr", "UndefinedOr", "NullishOr"]);
-const chainMethods = new Set(["pipe", "check", "annotate"]);
+// `optionalWith` and `annotations` are the Effect 3 names.
+const nullableWrappers = new Set([
+    "optional",
+    "optionalKey",
+    "optionalWith",
+    "NullOr",
+    "UndefinedOr",
+    "NullishOr",
+]);
+const chainMethods = new Set(["pipe", "check", "annotate", "annotations"]);
 const isRedactedSchema = (node) => node?.type === "CallExpression" &&
     (memberOf(node.callee, "Schema")?.startsWith("Redacted") ?? false);
+// Effect 3 spells it `Config.redacted`, which also wraps a config: `Config.redacted(Config.string(…))`.
 const isRedactedConfig = (node) => {
     const name = calleeOf(node, "Config");
-    return (name === "redacted" ||
-        (name === "schema" && isRedactedSchema(node.arguments[0])) ||
-        calleeOf(node.parent, "Config") === "redacted");
+    if (name === "Redacted" || name === "redacted")
+        return true;
+    return (name === "schema" && node?.type === "CallExpression" && isRedactedSchema(node.arguments[0]));
 };
 const isRedactedReference = (node) => (memberOf(node, "Schema") ?? calleeOf(node, "Schema"))?.startsWith("Redacted") ?? false;
 // `Schema.String`, `Schema.NonEmptyString.check(…)`, `Schema.optional(Schema.String)`: a schema
@@ -68,7 +77,7 @@ export const redactedSecretNamesRule = defineRule({
             description: "Read configuration values and declare Schema fields whose name looks like a secret as `Redacted`.",
         },
         messages: {
-            notRedacted: "`{{name}}` looks like a secret: read it with `Config.redacted` or `Config.schema(Schema.Redacted(...), name)`.",
+            notRedacted: "`{{name}}` looks like a secret: read it with `Config.schema(Schema.Redacted(...), name)` or, v3: `Config.redacted(name)`, v4: `Config.Redacted(name)`.",
             fieldNotRedacted: "`{{name}}` looks like a secret: declare it as `Schema.Redacted(...)` so it stays out of logs.",
         },
         schema: [
@@ -84,7 +93,9 @@ export const redactedSecretNamesRule = defineRule({
     createOnce(context) {
         let secretFields = defaultSecretFields;
         const checkConfig = (node) => {
-            if (calleeOf(node, "Config") === undefined || isRedactedConfig(node))
+            if (calleeOf(node, "Config") === undefined)
+                return;
+            if (isRedactedConfig(node) || isRedactedConfig(node.parent))
                 return;
             for (const argument of node.arguments) {
                 if (argument.type === "Literal" &&

package/dist/rules/run-only-in-runner.d.ts

@@ -0,0 +1 @@
+export declare const runOnlyInRunnerRule: import("@oxlint/plugins").Rule;

package/dist/rules/run-only-in-runner.js

@@ -0,0 +1,33 @@
+import { defineRule } from "@oxlint/plugins";
+import { runnerName } from "../shared/effect-runners.js";
+import { isEntryFile } from "../shared/entry-files.js";
+import { isTestFile } from "../shared/test-files.js";
+// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
+export const runOnlyInRunnerRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Run Effect programs only at the entry point. Entry and test files are skipped.",
+        },
+        messages: {
+            runOutsideEntry: "`{{name}}` runs an Effect program: only the entry point may do that.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        let skipped = false;
+        return {
+            // How tests run their Effects is `prefer-effect-vitest`'s concern.
+            before() {
+                skipped = isEntryFile(context) || isTestFile(context);
+            },
+            MemberExpression(node) {
+                if (skipped)
+                    return;
+                const name = runnerName(node);
+                if (name !== undefined)
+                    context.report({ node, messageId: "runOutsideEntry", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/service-key-matches-name.js

@@ -1,9 +1,18 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf } from "../shared/effect-ast.js";
-// `class X extends Context.Service<X, Shape>()(key)`: the outer call carries the key.
-const contextServiceKey = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
-    ? superClass.arguments[0]
-    : undefined;
+// `class X extends Context.Service<X, Shape>()(key)` and Effect 3 `Effect.Service<X>()(key, …)`:
+// the outer call carries the key. Effect 3 `Context.Tag(key)<X, Shape>()`: the inner one does.
+const serviceKey = (superClass) => {
+    if (superClass?.type !== "CallExpression")
+        return undefined;
+    const factory = superClass.callee;
+    if (calleeOf(factory, "Context") === "Service" || calleeOf(factory, "Effect") === "Service") {
+        return superClass.arguments[0];
+    }
+    return factory.type === "CallExpression" && calleeOf(factory, "Context") === "Tag"
+        ? factory.arguments[0]
+        : undefined;
+};
 const literalKey = (node) => {
     if (node?.type === "Literal" && typeof node.value === "string")
         return node.value;
@@ -30,7 +39,7 @@ export const serviceKeyMatchesNameRule = defineRule({
     meta: {
         type: "suggestion",
         docs: {
-            description: "Key a `Context.Service` class with its own name, alone or after a path prefix.",
+            description: "Key a service class with its own name, alone or after a path prefix (v3: `Context.Tag`/`Effect.Service`, v4: `Context.Service`).",
         },
         hasSuggestions: true,
         messages: {
@@ -40,7 +49,7 @@ export const serviceKeyMatchesNameRule = defineRule({
     },
     createOnce(context) {
         const checkClass = (node) => {
-            const keyNode = contextServiceKey(node.superClass);
+            const keyNode = serviceKey(node.superClass);
             const key = literalKey(keyNode);
             const name = className(node);
             if (keyNode === undefined || key === undefined || name === undefined)

package/dist/rules/service-port-shape-only.js

@@ -1,15 +1,13 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, memberOf } from "../shared/effect-ast.js";
-const legacyServices = [
-    ["Effect", "Service"],
-    ["Context", "Tag"],
-    ["Context", "GenericTag"],
-];
-const implementationStatics = new Set(["layer", "Default"]);
+// `Live` is the Effect 3 convention for the static layer.
+const implementationStatics = new Set(["layer", "Default", "Live"]);
 // `class X extends Context.Service<X, Shape>()(id, options?)`: the outer call carries the id.
 const contextServiceIdCall = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
     ? superClass
     : undefined;
+// Effect 3 `class X extends Context.Tag(id)<X, Shape>() {}`: shape only, like `Context.Service`.
+const isContextTagClass = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Tag";
 const staticMemberName = (member) => (member.type === "PropertyDefinition" || member.type === "MethodDefinition") &&
     member.static &&
     member.key.type === "Identifier"
@@ -19,20 +17,20 @@ export const servicePortShapeOnlyRule = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Keep a `Context.Service` port a pure contract, with implementations in separate Layers.",
+            description: "Keep a service port a pure contract (v3: `Context.Tag`, v4: `Context.Service`), with implementations in separate Layers.",
         },
         messages: {
             makeOption: "Declare the port as shape only: move the implementation into a Layer in its own adapter file.",
             staticImplementation: "Do not attach `static {{name}}` to the port: provide the implementation as a Layer in its own adapter file.",
-            legacyService: "Use `class X extends Context.Service<X, Shape>()(id) {}` instead of `{{name}}`.",
+            effectService: "`Effect.Service` ties the port to its implementation: declare the port shape only (v3: `Context.Tag`, v4: `Context.Service`) and provide the implementation as a Layer in its own adapter file.",
         },
     },
     createOnce(context) {
         const checkClass = (node) => {
             const idCall = contextServiceIdCall(node.superClass);
-            if (idCall === undefined)
+            if (idCall === undefined && !isContextTagClass(node.superClass))
                 return;
-            const options = idCall.arguments[1];
+            const options = idCall?.arguments[1];
             if (options !== undefined)
                 context.report({ node: options, messageId: "makeOption" });
             for (const member of node.body.body) {
@@ -50,14 +48,8 @@ export const servicePortShapeOnlyRule = defineRule({
             ClassDeclaration: checkClass,
             ClassExpression: checkClass,
             MemberExpression(node) {
-                for (const [object, property] of legacyServices) {
-                    if (memberOf(node, object) === property) {
-                        context.report({
-                            node,
-                            messageId: "legacyService",
-                            data: { name: `${object}.${property}` },
-                        });
-                    }
+                if (memberOf(node, "Effect") === "Service") {
+                    context.report({ node, messageId: "effectService" });
                 }
             },
         };

package/dist/rules/single-style-per-function.js

@@ -1,20 +1,39 @@
 import { defineRule } from "@oxlint/plugins";
-import { isEffectGenerator, memberOf } from "../shared/effect-ast.js";
+import { isEffectGenerator, isServerComponent, memberOf, } from "../shared/effect-ast.js";
+import { isTestFile } from "../shared/test-files.js";
 const isThenCall = (node) => node.callee.type === "MemberExpression" &&
     !node.callee.computed &&
     node.callee.property.type === "Identifier" &&
     node.callee.property.name === "then";
 const testRunners = new Set(["test", "it"]);
-// `test(…)`, `test.only(…)`, `test.each(table)(…)`: the callee chain roots at `test` or `it`.
-const isTestCallback = (fn) => {
+const testHooks = new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
+// `test(…)`, `test.only(…)`, `test.each(table)(…)`: the callee chain roots at the runner or hook.
+const testRoleOf = (fn) => {
     const call = fn.parent;
     if (call?.type !== "CallExpression" || !call.arguments.some((arg) => arg === fn))
-        return false;
+        return undefined;
     let callee = call.callee;
     while (callee.type === "MemberExpression" || callee.type === "CallExpression") {
         callee = callee.type === "MemberExpression" ? callee.object : callee.callee;
     }
-    return callee.type === "Identifier" && testRunners.has(callee.name);
+    if (callee.type !== "Identifier")
+        return undefined;
+    if (testRunners.has(callee.name))
+        return "test";
+    if (testHooks.has(callee.name))
+        return "hook";
+    return undefined;
+};
+// Awaiting promise-based fixtures and then one Effect program reads as Arrange/Act/Assert;
+// a second Effect step is where promise and Effect sequencing start to interleave.
+const interleavesEffectSteps = (frame) => {
+    const effectSteps = frame.promiseSteps.filter((step) => step.involvesEffect);
+    return (effectSteps.length > 1 || effectSteps.some((step) => step.node.type !== "AwaitExpression"));
+};
+const reportFor = {
+    test: "asyncEffectTest",
+    hook: "asyncEffectHook",
+    helper: "asyncEffectHelper",
 };
 export const singleStylePerFunctionRule = defineRule({
     meta: {
@@ -25,31 +44,60 @@ export const singleStylePerFunctionRule = defineRule({
         messages: {
             asyncEffect: "This function builds Effects: drop `async` and lift promises with `Effect.tryPromise({ try, catch })`.",
             promiseStep: "Do not mix promises with Effect in the same function: lift the promise with `Effect.tryPromise({ try, catch })`.",
-            asyncEffectTest: "This test mixes promises with Effect: make its body one Effect, with `it.effect` from `@effect/vitest` or by returning a single test runner call from a non-async callback.",
+            asyncEffectTest: "This test chains promises around Effect: await a single program and assert on its result, or make its body one Effect with `it.effect` from `@effect/vitest`.",
+            asyncEffectHook: "This hook chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`, or build the fixture as a Layer with `layer` from `@effect/vitest`.",
+            asyncEffectHelper: "This test helper chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`.",
         },
+        schema: [],
     },
     createOnce(context) {
         const frames = [];
         const current = () => frames.at(-1);
+        const openSteps = [];
+        let inTestFile = false;
+        // In a test file a helper such as `probe` or `captureLines` is a promise/Effect boundary
+        // like the test that calls it, so it gets the same allowance.
+        const roleOf = (fn) => testRoleOf(fn) ?? (inTestFile && !isEffectGenerator(fn) ? "helper" : undefined);
         const enter = (fn) => {
-            frames.push({ fn, effectful: isEffectGenerator(fn), promiseSteps: [] });
+            frames.push({
+                fn,
+                effectful: isEffectGenerator(fn),
+                rendersJsx: false,
+                promiseSteps: [],
+            });
+        };
+        const openStep = (node) => {
+            const step = { node, involvesEffect: false };
+            current()?.promiseSteps.push(step);
+            openSteps.push(step);
         };
         const exit = () => {
             const frame = frames.pop();
-            if (frame === undefined || !frame.effectful)
+            if (frame === undefined)
                 return;
-            // One report per test: the remedy is the test's shape, not each promise in it.
-            if (isTestCallback(frame.fn)) {
-                if (frame.fn.async || frame.promiseSteps.length > 0)
-                    context.report({ node: frame.fn, messageId: "asyncEffectTest" });
+            // One report per test or hook: the remedy is its shape, not each promise in it.
+            const role = roleOf(frame.fn);
+            if (role !== undefined) {
+                if (interleavesEffectSteps(frame))
+                    context.report({ node: frame.fn, messageId: reportFor[role] });
                 return;
             }
+            if (!frame.effectful || isServerComponent(frame.fn, frame.rendersJsx))
+                return;
             if (frame.fn.async)
                 context.report({ node: frame.fn, messageId: "asyncEffect" });
-            for (const node of frame.promiseSteps)
-                context.report({ node, messageId: "promiseStep" });
+            for (const step of frame.promiseSteps)
+                context.report({ node: step.node, messageId: "promiseStep" });
+        };
+        const markJsx = () => {
+            const frame = current();
+            if (frame !== undefined)
+                frame.rendersJsx = true;
         };
         return {
+            before() {
+                inTestFile = isTestFile(context);
+            },
             ArrowFunctionExpression: enter,
             FunctionExpression: enter,
             FunctionDeclaration: enter,
@@ -57,20 +105,33 @@ export const singleStylePerFunctionRule = defineRule({
             "FunctionExpression:exit": exit,
             "FunctionDeclaration:exit": exit,
             MemberExpression(node) {
-                const frame = current();
                 const name = memberOf(node, "Effect");
+                if (name === undefined)
+                    return;
+                // A step involves Effect wherever it appears in it, nested callbacks included.
+                for (const step of openSteps)
+                    step.involvesEffect = true;
+                const frame = current();
+                if (frame === undefined)
+                    return;
                 // `Effect.run*` is how an async boundary legitimately hands off to Effect (P27);
-                // where it may appear is run-only-at-entry's business.
-                if (frame !== undefined && name !== undefined && !name.startsWith("run")) {
+                // where it may appear is run-only-in-runner's business.
+                if (!name.startsWith("run"))
                     frame.effectful = true;
-                }
             },
-            AwaitExpression(node) {
-                current()?.promiseSteps.push(node);
+            JSXElement: markJsx,
+            JSXFragment: markJsx,
+            AwaitExpression: openStep,
+            "AwaitExpression:exit"() {
+                openSteps.pop();
             },
             CallExpression(node) {
                 if (isThenCall(node))
-                    current()?.promiseSteps.push(node);
+                    openStep(node);
+            },
+            "CallExpression:exit"(node) {
+                if (isThenCall(node))
+                    openSteps.pop();
             },
         };
     },

package/dist/rules/split-success-path-from-error-handling.d.ts

@@ -0,0 +1 @@
+export declare const splitSuccessPathFromErrorHandlingRule: import("@oxlint/plugins").Rule;

package/dist/rules/split-success-path-from-error-handling.js

@@ -0,0 +1,137 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEffectGenerator, isInsideEffectGeneratorBody, memberOf, nearestFunction, } from "../shared/effect-ast.js";
+import { isTestFile } from "../shared/test-files.js";
+// mapError, orElse and orElseSucceed stay allowed: they name a failure or give an alternative
+// without opening a handling branch inside the success path.
+const errorHandlers = new Set([
+    "catch",
+    "catchAll",
+    "catchCause",
+    "catchCauseFilter",
+    "catchCauseIf",
+    "catchDefect",
+    "catchEager",
+    "catchFilter",
+    "catchIf",
+    "catchReason",
+    "catchReasons",
+    "catchTag",
+    "catchTags",
+    "either",
+    "exit",
+    "match",
+    "matchCause",
+    "matchCauseEffect",
+    "matchEffect",
+    "result",
+    "sandbox",
+]);
+// Effect 4 names first, then the v3 ones without a v4 counterpart.
+const iterationCombinators = new Set([
+    "filter",
+    "filterMap",
+    "filterMapEffect",
+    "findFirst",
+    "findFirstFilter",
+    "forEach",
+    "partition",
+    "reduce",
+    "validate",
+    "dropUntil",
+    "dropWhile",
+    "every",
+    "exists",
+    "mergeAll",
+    "reduceWhile",
+    "takeUntil",
+    "takeWhile",
+    "validateAll",
+    "validateFirst",
+]);
+const failureCatchers = new Set([
+    "catch",
+    "catchAll",
+    "catchFilter",
+    "catchIf",
+    "catchTag",
+    "catchTags",
+]);
+const isEffectDie = (node) => ["die", "dieMessage"].includes(memberOf(node, "Effect") ?? "");
+const returnedExpression = (fn) => {
+    if (fn.body?.type !== "BlockStatement")
+        return fn.body;
+    const [statement, ...rest] = fn.body.body;
+    return rest.length === 0 && statement?.type === "ReturnStatement" ? statement.argument : null;
+};
+const onlyDies = (handler) => {
+    if (isEffectDie(handler))
+        return true;
+    if (handler.type !== "ArrowFunctionExpression" && handler.type !== "FunctionExpression") {
+        return false;
+    }
+    const returned = returnedExpression(handler);
+    return returned?.type === "CallExpression" && isEffectDie(returned.callee);
+};
+// Turning a failure into a defect is a selective `orDie`, which stays allowed: it declares the case
+// untracked rather than handling it. The handler is the last argument in both the pipeable and the
+// data-first forms; `catchTags` takes an object of handlers and is exempt only when all of them die.
+const isDieOnlyCatch = (node, name) => {
+    const call = node.parent;
+    if (call?.type !== "CallExpression" || call.callee !== node || !failureCatchers.has(name)) {
+        return false;
+    }
+    const handler = call.arguments.at(-1);
+    if (handler === undefined)
+        return false;
+    if (name !== "catchTags")
+        return onlyDies(handler);
+    return (handler.type === "ObjectExpression" &&
+        handler.properties.length > 0 &&
+        handler.properties.every((property) => property.type === "Property" && onlyDies(property.value)));
+};
+// A handler in the callback of an iteration (`Effect.forEach(items, (item) => ... Effect.catch ...)`)
+// handles each element on its own; moved to the `Effect.fn` pipeables, the first failure would stop
+// them all. Other callbacks (`flatMap`, `tap`) stay on the success path and are still reported.
+const isInsideIterationCallback = (node) => {
+    for (let fn = nearestFunction(node); fn && !isEffectGenerator(fn); fn = nearestFunction(fn)) {
+        const call = fn.parent;
+        if (call?.type === "CallExpression" &&
+            iterationCombinators.has(memberOf(call.callee, "Effect") ?? "")) {
+            return true;
+        }
+    }
+    return false;
+};
+export const splitSuccessPathFromErrorHandlingRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Keep only the success path in Effect generators and handle errors in the second argument of `Effect.fn`. Test files are skipped.",
+        },
+        messages: {
+            handlerInGenerator: "Move `Effect.{{name}}` out of the generator: keep the success path in the body and handle errors in the pipeable arguments of `Effect.fn`.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // In a test the failure is the observed outcome, not a branch of the success path.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            MemberExpression(node) {
+                const name = memberOf(node, "Effect");
+                if (inTestFile ||
+                    name === undefined ||
+                    !errorHandlers.has(name) ||
+                    !isInsideEffectGeneratorBody(node) ||
+                    isInsideIterationCallback(node) ||
+                    isDieOnlyCatch(node, name)) {
+                    return;
+                }
+                context.report({ node, messageId: "handlerInGenerator", data: { name } });
+            },
+        };
+    },
+});

package/dist/shared/effect-ast.d.ts

@@ -7,3 +7,4 @@ export declare const isEffectFnApplication: (node: ESTree.Node | null | undefine
 export declare const isEffectGenerator: (fn: FunctionNode) => boolean;
 export declare const isInsideEffectGeneratorBody: (node: ESTree.Node) => boolean;
 export declare const nearestFunction: (node: ESTree.Node) => FunctionNode | undefined;
+export declare const isServerComponent: (fn: FunctionNode, rendersJsx: boolean) => boolean;