@doubleloop-io/oxlint-plugin-effect 0.0.0-stage → 0.1.0-rc.1

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { defaultEntryFiles } from "./shared/entry-files.ts";
+export { defaultTestFiles } from "./shared/test-files.ts";
+export declare const pluginName = "dl-effect";
+export declare const pluginPath: string;
+declare const dlEffectPlugin: import("@oxlint/plugins").Plugin;
+export default dlEffectPlugin;

package/dist/index.js

@@ -0,0 +1,75 @@
+import { fileURLToPath } from "node:url";
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { adapterImportBoundaryRule } from "./rules/adapter-import-boundary.js";
+import { allErrorsHandledAtBoundaryRule } from "./rules/all-errors-handled-at-boundary.js";
+import { antiSlopNoManualEffectErrorTagRule } from "./rules/anti-slop-no-manual-effect-error-tag.js";
+import { antiSlopNoServiceConstructorImportsRule } from "./rules/anti-slop-no-service-constructor-imports.js";
+import { antiSlopPreferEffectMatchRule } from "./rules/anti-slop-prefer-effect-match.js";
+import { errorHandlingInEffectFnHandlerRule } from "./rules/error-handling-in-effect-fn-handler.js";
+import { exportedSchemaIdentifierRule } from "./rules/exported-schema-identifier.js";
+import { noAsymmetricMatchHandlersRule } from "./rules/no-asymmetric-match-handlers.js";
+import { noBareErrorInEffectRule } from "./rules/no-bare-error-in-effect.js";
+import { noEffectPromiseRule } from "./rules/no-effect-promise.js";
+import { noEffectReturnTypeRule } from "./rules/no-effect-return-type.js";
+import { noInlineSchemaCodecRule } from "./rules/no-inline-schema-codec.js";
+import { noInlineYieldStarRule } from "./rules/no-inline-yield-star.js";
+import { noManualDiscriminantComparisonRule } from "./rules/no-manual-discriminant-comparison.js";
+import { noManualDiscriminantConstructionRule } from "./rules/no-manual-discriminant-construction.js";
+import { noNestedMatchRule } from "./rules/no-nested-match.js";
+import { noParameterlessCatchAllRule } from "./rules/no-parameterless-catch-all.js";
+import { noProvideOnDefinitionRule } from "./rules/no-provide-on-definition.js";
+import { noTransportTypesInGeneratorRule } from "./rules/no-transport-types-in-generator.js";
+import { noYieldedMatchRule } from "./rules/no-yielded-match.js";
+import { preferEffectFnRule } from "./rules/prefer-effect-fn.js";
+import { preferEffectVitestRule } from "./rules/prefer-effect-vitest.js";
+import { provideNamedLayerRule } from "./rules/provide-named-layer.js";
+import { redactedSecretNamesRule } from "./rules/redacted-secret-names.js";
+import { runOnlyInRunnerRule } from "./rules/run-only-in-runner.js";
+import { serviceBuiltWithOfRule } from "./rules/service-built-with-of.js";
+import { serviceKeyMatchesNameRule } from "./rules/service-key-matches-name.js";
+import { servicePortShapeOnlyRule } from "./rules/service-port-shape-only.js";
+import { singleStylePerFunctionRule } from "./rules/single-style-per-function.js";
+import { tryObjectFormRule } from "./rules/try-object-form.js";
+import { untracedRecursionRule } from "./rules/untraced-recursion.js";
+export { defaultEntryFiles } from "./shared/entry-files.js";
+export { defaultTestFiles } from "./shared/test-files.js";
+export const pluginName = "dl-effect";
+// Resolved at runtime so it points at this file both from the sources and from `dist/`.
+export const pluginPath = fileURLToPath(import.meta.url);
+const dlEffectPlugin = eslintCompatPlugin({
+    meta: { name: pluginName },
+    rules: {
+        "anti-slop-no-manual-effect-error-tag": antiSlopNoManualEffectErrorTagRule,
+        "anti-slop-no-service-constructor-imports": antiSlopNoServiceConstructorImportsRule,
+        "anti-slop-prefer-effect-match": antiSlopPreferEffectMatchRule,
+        "adapter-import-boundary": adapterImportBoundaryRule,
+        "all-errors-handled-at-boundary": allErrorsHandledAtBoundaryRule,
+        "error-handling-in-effect-fn-handler": errorHandlingInEffectFnHandlerRule,
+        "exported-schema-identifier": exportedSchemaIdentifierRule,
+        "no-asymmetric-match-handlers": noAsymmetricMatchHandlersRule,
+        "no-bare-error-in-effect": noBareErrorInEffectRule,
+        "no-effect-promise": noEffectPromiseRule,
+        "no-effect-return-type": noEffectReturnTypeRule,
+        "no-inline-schema-codec": noInlineSchemaCodecRule,
+        "no-inline-yield-star": noInlineYieldStarRule,
+        "no-manual-discriminant-comparison": noManualDiscriminantComparisonRule,
+        "no-manual-discriminant-construction": noManualDiscriminantConstructionRule,
+        "no-nested-match": noNestedMatchRule,
+        "no-parameterless-catch-all": noParameterlessCatchAllRule,
+        "no-provide-on-definition": noProvideOnDefinitionRule,
+        "no-transport-types-in-generator": noTransportTypesInGeneratorRule,
+        "no-yielded-match": noYieldedMatchRule,
+        "prefer-effect-fn": preferEffectFnRule,
+        "prefer-effect-vitest": preferEffectVitestRule,
+        "provide-named-layer": provideNamedLayerRule,
+        "redacted-secret-names": redactedSecretNamesRule,
+        "run-only-in-runner": runOnlyInRunnerRule,
+        "service-built-with-of": serviceBuiltWithOfRule,
+        "service-key-matches-name": serviceKeyMatchesNameRule,
+        "service-port-shape-only": servicePortShapeOnlyRule,
+        "single-style-per-function": singleStylePerFunctionRule,
+        "try-object-form": tryObjectFormRule,
+        "untraced-recursion": untracedRecursionRule,
+    },
+});
+export default dlEffectPlugin;

package/dist/presets/all.d.ts

@@ -0,0 +1,7 @@
+declare const all: {
+    jsPlugins: string[];
+    rules: {
+        [k: string]: "warn";
+    };
+};
+export default all;

package/dist/presets/all.js

@@ -0,0 +1,9 @@
+import dlEffectPlugin, { pluginName, pluginPath } from "../index.js";
+const allRules = Object.fromEntries(Object.keys(dlEffectPlugin.rules).map((rule) => [`${pluginName}/${rule}`, "warn"]));
+// Absolute because an imported config object carries no location of its own: a relative
+// path would resolve against the consumer's config file, not this package.
+const all = {
+    jsPlugins: [pluginPath],
+    rules: allRules,
+};
+export default all;

package/dist/presets/all.json

@@ -0,0 +1,38 @@
+{
+    "jsPlugins": [
+        "../index.js"
+    ],
+    "rules": {
+        "dl-effect/anti-slop-no-manual-effect-error-tag": "warn",
+        "dl-effect/anti-slop-no-service-constructor-imports": "warn",
+        "dl-effect/anti-slop-prefer-effect-match": "warn",
+        "dl-effect/adapter-import-boundary": "warn",
+        "dl-effect/all-errors-handled-at-boundary": "warn",
+        "dl-effect/error-handling-in-effect-fn-handler": "warn",
+        "dl-effect/exported-schema-identifier": "warn",
+        "dl-effect/no-asymmetric-match-handlers": "warn",
+        "dl-effect/no-bare-error-in-effect": "warn",
+        "dl-effect/no-effect-promise": "warn",
+        "dl-effect/no-effect-return-type": "warn",
+        "dl-effect/no-inline-schema-codec": "warn",
+        "dl-effect/no-inline-yield-star": "warn",
+        "dl-effect/no-manual-discriminant-comparison": "warn",
+        "dl-effect/no-manual-discriminant-construction": "warn",
+        "dl-effect/no-nested-match": "warn",
+        "dl-effect/no-parameterless-catch-all": "warn",
+        "dl-effect/no-provide-on-definition": "warn",
+        "dl-effect/no-transport-types-in-generator": "warn",
+        "dl-effect/no-yielded-match": "warn",
+        "dl-effect/prefer-effect-fn": "warn",
+        "dl-effect/prefer-effect-vitest": "warn",
+        "dl-effect/provide-named-layer": "warn",
+        "dl-effect/redacted-secret-names": "warn",
+        "dl-effect/run-only-in-runner": "warn",
+        "dl-effect/service-built-with-of": "warn",
+        "dl-effect/service-key-matches-name": "warn",
+        "dl-effect/service-port-shape-only": "warn",
+        "dl-effect/single-style-per-function": "warn",
+        "dl-effect/try-object-form": "warn",
+        "dl-effect/untraced-recursion": "warn"
+    }
+}

package/dist/rules/adapter-import-boundary.d.ts

@@ -0,0 +1,7 @@
+type Deps = {
+    readonly isAdapterDir: (dir: string) => boolean;
+};
+export declare const buildsLayer: (source: string) => boolean;
+export declare const makeAdapterImportBoundaryRule: (deps: Deps) => import("@oxlint/plugins").Rule;
+export declare const adapterImportBoundaryRule: import("@oxlint/plugins").Rule;
+export {};

package/dist/rules/adapter-import-boundary.js

@@ -0,0 +1,103 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { isEntryFile } from "../shared/entry-files.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// Only the APIs that build a service implementation, so composition of existing layers
+// (`mergeAll`, `provide`, `merge`) leaves the entry point out. Longest names first: the
+// alternation is ordered, and `effect` would otherwise shadow `effectContext`.
+// `scoped*`, `context`, `service` and `function` exist in Effect 3 only; `unwrap` and
+// `mock` in Effect 4 only. Naming the API instead of the binding keeps `FooLive` covered.
+const LAYER_CONSTRUCTORS = [
+    "effectContext",
+    "effectDiscard",
+    "succeedContext",
+    "scopedContext",
+    "scopedDiscard",
+    "syncContext",
+    "function",
+    "service",
+    "context",
+    "succeed",
+    "scoped",
+    "effect",
+    "unwrap",
+    "sync",
+    "mock",
+];
+// Like the other rules, names are matched literally: `import * as L from "effect/Layer"` escapes.
+const LAYER_CONSTRUCTION = new RegExp(`\\bLayer\\.(?:${LAYER_CONSTRUCTORS.join("|")})\\s*\\(`, "u");
+export const buildsLayer = (source) => LAYER_CONSTRUCTION.test(source);
+// Test files are skipped so a fixture layer cannot promote a domain directory to an adapter.
+const isSource = (entry) => entry.endsWith(".ts") && !entry.endsWith(".test.ts");
+const buildsLayerIn = (dir) => {
+    try {
+        return readdirSync(dir)
+            .filter(isSource)
+            .some((entry) => buildsLayer(readFileSync(resolve(dir, entry), "utf8")));
+    }
+    catch {
+        return false;
+    }
+};
+const cachedBuildsLayerIn = () => {
+    const known = new Map();
+    return (dir) => {
+        const seen = known.get(dir);
+        if (seen !== undefined)
+            return seen;
+        const verdict = buildsLayerIn(dir);
+        known.set(dir, verdict);
+        return verdict;
+    };
+};
+const isRelativeImport = (source) => source.startsWith("./") || source.startsWith("../");
+const toPosix = (path) => path.split(sep).join("/");
+export const makeAdapterImportBoundaryRule = (deps) => defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Import adapters only at the entry point, and never from another adapter. Entry and test files are skipped.",
+        },
+        messages: {
+            adapterOutsideEntry: "`{{adapter}}` is an adapter: depend on its port instead and let the entry point provide the Layer.",
+            crossAdapter: "`{{adapter}}` is another adapter: depend on its port instead and let the entry point compose the Layers.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    entryFiles: filePatternsSchema,
+                    testFiles: filePatternsSchema,
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const ownDir = dirname(context.filename);
+        // A test composes the Layers it exercises, so it is an entry point too.
+        const composesLayers = isEntryFile(context) || isTestFile(context);
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (composesLayers || !isRelativeImport(source))
+                    return;
+                const targetDir = dirname(resolve(ownDir, source));
+                if (targetDir === ownDir || !deps.isAdapterDir(targetDir))
+                    return;
+                context.report({
+                    node,
+                    messageId: deps.isAdapterDir(ownDir)
+                        ? "crossAdapter"
+                        : "adapterOutsideEntry",
+                    data: { adapter: toPosix(relative(context.cwd, targetDir)) },
+                });
+            },
+        };
+    },
+});
+export const adapterImportBoundaryRule = makeAdapterImportBoundaryRule({
+    isAdapterDir: cachedBuildsLayerIn(),
+});

package/dist/rules/all-errors-handled-at-boundary.d.ts

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

package/dist/rules/all-errors-handled-at-boundary.js

@@ -0,0 +1,111 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isServerComponent, memberOf, nearestFunction, } from "../shared/effect-ast.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// The *Exit runners hand failures back as values, so an open error channel cannot leak there.
+// `NodeRuntime.runMain`/`BunRuntime.runMain` are boundaries too: they log the Cause and exit with
+// code 1, which is the right outcome for a process failing to start (a ConfigError, a busy port).
+const effectRunners = new Set(["runPromise", "runSync", "runFork", "runCallback"]);
+const isRunnerCall = (node) => effectRunners.has(calleeOf(node, "Effect") ?? "");
+const isEffectTypeName = (name) => (name.type === "Identifier" && name.name === "Effect") ||
+    (name.type === "TSQualifiedName" &&
+        name.left.type === "Identifier" &&
+        name.left.name === "Effect" &&
+        name.right.name === "Effect");
+const isClosedEffectType = (type) => type?.type === "TSTypeReference" &&
+    isEffectTypeName(type.typeName) &&
+    type.typeArguments?.params[1]?.type === "TSNeverKeyword";
+const parameterType = (identifier) => {
+    for (let fn = nearestFunction(identifier); fn; fn = nearestFunction(fn)) {
+        for (const param of fn.params) {
+            if (param.type === "Identifier" && param.name === identifier.name) {
+                return param.typeAnnotation?.typeAnnotation;
+            }
+        }
+    }
+    return undefined;
+};
+// They turn every failure into a success value, so whatever comes before cannot leak.
+const failureToValue = new Set(["result", "exit"]);
+const isPipeCall = (node) => node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "pipe";
+// `Effect.result(program)` or `program.pipe(…, Effect.result)`.
+const endsWithFailureToValue = (node) => {
+    const last = isPipeCall(node) ? node.arguments.at(-1) : undefined;
+    const step = last === undefined ? calleeOf(node, "Effect") : memberOf(last, "Effect");
+    return failureToValue.has(step ?? "");
+};
+const hasClosedErrorChannel = (node) => {
+    if (node?.type === "TSSatisfiesExpression")
+        return isClosedEffectType(node.typeAnnotation);
+    if (node?.type === "Identifier")
+        return isClosedEffectType(parameterType(node));
+    if (node?.type === "CallExpression")
+        return endsWithFailureToValue(node);
+    return false;
+};
+export const allErrorsHandledAtBoundaryRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Close the error channel to `never` before running an Effect at the boundary. Test files are skipped.",
+        },
+        messages: {
+            openErrorChannel: "Close the error channel before running: `program satisfies Effect.Effect<A, never>`, or a runner parameter typed `Effect.Effect<A, never, never>`.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        const frames = [];
+        let inTestFile = false;
+        const enter = (fn) => {
+            frames.push({ fn, rendersJsx: false, openRuns: [] });
+        };
+        // The JSX can follow the run, so whether the function is a Server Component is known only on exit.
+        const exit = () => {
+            const frame = frames.pop();
+            if (frame === undefined || isServerComponent(frame.fn, frame.rendersJsx))
+                return;
+            for (const node of frame.openRuns)
+                context.report({ node, messageId: "openErrorChannel" });
+        };
+        const markJsx = () => {
+            const frame = frames.at(-1);
+            if (frame !== undefined)
+                frame.rendersJsx = true;
+        };
+        return {
+            // A test is not a boundary: a rejected run fails it with the error, which is the point.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            ArrowFunctionExpression: enter,
+            FunctionExpression: enter,
+            FunctionDeclaration: enter,
+            "ArrowFunctionExpression:exit": exit,
+            "FunctionExpression:exit": exit,
+            "FunctionDeclaration:exit": exit,
+            JSXElement: markJsx,
+            JSXFragment: markJsx,
+            CallExpression(node) {
+                if (inTestFile)
+                    return;
+                if (!isRunnerCall(node) || hasClosedErrorChannel(node.arguments[0]))
+                    return;
+                const frame = frames.at(-1);
+                if (frame === undefined)
+                    context.report({ node, messageId: "openErrorChannel" });
+                else
+                    frame.openRuns.push(node);
+            },
+        };
+    },
+});

package/dist/rules/anti-slop-no-manual-effect-error-tag.d.ts

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

package/dist/rules/anti-slop-no-manual-effect-error-tag.js

@@ -0,0 +1,32 @@
+import { defineRule } from "@oxlint/plugins";
+import { isInsideBroadEffectHandler, isReasonTagMember, isTagMember, tagMemberFromComparison, } from "../shared/tagged-values.js";
+export const antiSlopNoManualEffectErrorTagRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler.",
+        },
+        messages: {
+            tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+            reason: "Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler.",
+        },
+    },
+    createOnce(context) {
+        return {
+            BinaryExpression(node) {
+                const tagMember = tagMemberFromComparison(node);
+                if (tagMember === undefined || !isInsideBroadEffectHandler(node))
+                    return;
+                context.report({ node, messageId: isReasonTagMember(tagMember) ? "reason" : "tag" });
+            },
+            SwitchStatement(node) {
+                if (!isTagMember(node.discriminant) || !isInsideBroadEffectHandler(node))
+                    return;
+                context.report({
+                    node,
+                    messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag",
+                });
+            },
+        };
+    },
+});

package/dist/rules/anti-slop-no-service-constructor-imports.d.ts

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

package/dist/rules/anti-slop-no-service-constructor-imports.js

@@ -0,0 +1,49 @@
+import { defineRule } from "@oxlint/plugins";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+const serviceConstructorName = /^make[A-Z]/u;
+const isProjectLocalImport = (source) => source.startsWith("./") || source.startsWith("../");
+const importedName = (specifier) => specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+export const antiSlopNoServiceConstructorImportsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow project-local make<CapabilityName> imports outside test files.",
+        },
+        messages: {
+            serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // Tests build services from their constructors to inject fakes.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            ImportDeclaration(node) {
+                if (inTestFile || !isProjectLocalImport(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const name = importedName(specifier);
+                    if (!serviceConstructorName.test(name))
+                        continue;
+                    context.report({
+                        node: specifier,
+                        messageId: "serviceConstructorImport",
+                        data: { name },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/anti-slop-prefer-effect-match.d.ts

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

package/dist/rules/anti-slop-prefer-effect-match.js

@@ -0,0 +1,45 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEqualityComparison } from "../shared/tagged-values.js";
+const isLiteral = (node) => node.type === "Literal" || (node.type === "TemplateLiteral" && node.expressions.length === 0);
+export const antiSlopPreferEffectMatchRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Match from Effect for chained literal ternaries over the same value.",
+        },
+        messages: {
+            preferMatch: "Use Match from Effect instead of a chained literal ternary.",
+        },
+    },
+    createOnce(context) {
+        // The compared value is identified by its source text: no type or binding analysis.
+        const comparedValue = (node) => {
+            if (!isEqualityComparison(node))
+                return undefined;
+            if (isLiteral(node.left))
+                return context.sourceCode.getText(node.right);
+            if (isLiteral(node.right))
+                return context.sourceCode.getText(node.left);
+            return undefined;
+        };
+        return {
+            ConditionalExpression(node) {
+                if (node.parent?.type === "ConditionalExpression")
+                    return;
+                const value = comparedValue(node.test);
+                if (value === undefined)
+                    return;
+                let alternate = node.alternate;
+                let literalChecks = 1;
+                while (alternate.type === "ConditionalExpression") {
+                    if (comparedValue(alternate.test) !== value)
+                        return;
+                    literalChecks += 1;
+                    alternate = alternate.alternate;
+                }
+                if (literalChecks > 1)
+                    context.report({ node, messageId: "preferMatch" });
+            },
+        };
+    },
+});

package/dist/rules/error-handling-in-effect-fn-handler.d.ts

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

package/dist/rules/error-handling-in-effect-fn-handler.js

@@ -0,0 +1,144 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEffectGenerator, isInsideEffectGeneratorBody, memberOf, nearestFunction, } from "../shared/effect-ast.js";
+import { filePatternsSchema } from "../shared/file-globs.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 errorHandlingInEffectFnHandlerRule = 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: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    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/rules/exported-schema-identifier.d.ts

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