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

package/dist/rules/no-inline-yield-star.js

@@ -0,0 +1,230 @@
+import { defineRule } from "@oxlint/plugins";
+import { nearestFunction } from "../shared/effect-ast.js";
+const contains = (outer, inner) => outer[0] <= inner[0] && inner[1] <= outer[1];
+const isStandalone = (node) => {
+    const { parent } = node;
+    if (!parent)
+        return false;
+    if (parent.type === "ConditionalExpression" && parent.test !== node)
+        return isStandalone(parent);
+    if (parent.type === "LogicalExpression" && parent.right === node)
+        return isStandalone(parent);
+    if (parent.type === "VariableDeclarator")
+        return true;
+    if (parent.type === "AssignmentExpression")
+        return parent.parent.type === "ExpressionStatement";
+    return parent.type.endsWith("Statement");
+};
+const isInStatementList = (node) => {
+    const { parent } = node;
+    switch (parent?.type) {
+        case "BlockStatement":
+        case "Program":
+        case "StaticBlock":
+            return true;
+        case "SwitchCase":
+            return parent.test !== node;
+        default:
+            return false;
+    }
+};
+const statementOf = (node) => {
+    let current = node;
+    while (current.parent && !isInStatementList(current))
+        current = current.parent;
+    return current;
+};
+const logicalAssignments = new Set(["&&=", "||=", "??="]);
+// The extracted `const` runs before its statement, once and unconditionally: any position that
+// short-circuits, repeats or belongs to a nested statement would change when the effect runs.
+const runsOnceBeforeStatement = (child, parent, statement) => {
+    switch (parent.type) {
+        case "LogicalExpression":
+            return parent.left === child;
+        case "ConditionalExpression":
+            return parent.test === child;
+        case "AssignmentExpression":
+            return parent.left === child || !logicalAssignments.has(parent.operator);
+        case "ChainExpression":
+        case "ClassBody":
+        case "WhileStatement":
+        case "DoWhileStatement":
+            return false;
+        case "ForStatement":
+            return parent === statement && parent.init === child;
+        case "ForInStatement":
+        case "ForOfStatement":
+            return parent === statement && parent.right === child;
+        default:
+            return parent === statement || !parent.type.endsWith("Statement");
+    }
+};
+const canHoist = (node, statement) => {
+    let child = node;
+    while (child !== statement) {
+        const parent = child.parent;
+        if (!parent || !runsOnceBeforeStatement(child, parent, statement))
+            return false;
+        child = parent;
+    }
+    return true;
+};
+// Anything evaluated before a hoisted `yield*` must be hoisted with it, or the order of effects flips.
+const reordersEffects = (hoisted, effectful) => hoisted.some((target) => effectful.some((node) => node.range[1] <= target.range[0] &&
+    !hoisted.some((moved) => contains(moved.range, node.range) && moved.range[1] <= target.range[0])));
+const verbPrefix = /^(?:get|read|fetch|load|find|parse|decode|make|create|build|compute|resolve|from|to)(?=[A-Z])/;
+const reservedWords = new Set("arguments await break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof undefined var void while with yield".split(" "));
+const trailingName = (node) => {
+    switch (node.type) {
+        case "Identifier":
+            return node.name;
+        case "MemberExpression":
+            return !node.computed && node.property.type === "Identifier"
+                ? node.property.name
+                : undefined;
+        case "CallExpression":
+        case "NewExpression":
+            return trailingName(node.callee);
+        default:
+            return undefined;
+    }
+};
+// `yield* readSheet()` becomes `sheet`, `yield* reader.rows` becomes `rows`.
+const baseName = (node) => {
+    const name = node.argument ? trailingName(node.argument)?.replace(verbPrefix, "") : undefined;
+    if (name === undefined || name === "")
+        return "value";
+    const variable = name.charAt(0).toLowerCase() + name.slice(1);
+    return reservedWords.has(variable) ? "value" : variable;
+};
+const namesInUse = (scope) => {
+    const names = new Set();
+    const collect = (inner) => {
+        for (const variable of inner.variables)
+            names.add(variable.name);
+        for (const reference of inner.references)
+            names.add(reference.identifier.name);
+        inner.childScopes.forEach(collect);
+    };
+    collect(scope);
+    for (let outer = scope.upper; outer; outer = outer.upper) {
+        for (const name of outer.set.keys())
+            names.add(name);
+    }
+    return names;
+};
+// The parentheses of a call with a single argument belong to the call, not to the `yield*`.
+const replacedRange = (node, sourceCode) => {
+    const { parent } = node;
+    const callParens = (parent.type === "CallExpression" || parent.type === "NewExpression") &&
+        parent.arguments.length === 1
+        ? 1
+        : 0;
+    const wrappers = [];
+    let before = sourceCode.getTokenBefore(node);
+    let after = sourceCode.getTokenAfter(node);
+    while (before?.value === "(" && after?.value === ")") {
+        wrappers.push([before.range[0], after.range[1]]);
+        before = sourceCode.getTokenBefore(before);
+        after = sourceCode.getTokenAfter(after);
+    }
+    return wrappers[wrappers.length - 1 - callParens] ?? node.range;
+};
+const extraction = (statement, hoisted, sourceCode) => {
+    const taken = namesInUse(sourceCode.getScope(statement).variableScope);
+    const replacements = hoisted.map((node) => {
+        let name = baseName(node);
+        for (let suffix = 2; taken.has(name); suffix++)
+            name = `${baseName(node)}${suffix}`;
+        taken.add(name);
+        return { node, name, range: replacedRange(node, sourceCode) };
+    });
+    const { text } = sourceCode;
+    const rewrite = (range, self) => {
+        const inside = replacements.filter((replacement) => replacement.node !== self && contains(range, replacement.range));
+        const outermost = inside
+            .filter((replacement) => inside.every((other) => other === replacement || !contains(other.range, replacement.range)))
+            .toSorted((left, right) => left.range[0] - right.range[0]);
+        let result = "";
+        let cursor = range[0];
+        for (const replacement of outermost) {
+            result += text.slice(cursor, replacement.range[0]) + replacement.name;
+            cursor = replacement.range[1];
+        }
+        return result + text.slice(cursor, range[1]);
+    };
+    const lineStart = text.lastIndexOf("\n", statement.range[0] - 1) + 1;
+    const indentation = text.slice(lineStart, statement.range[0]);
+    const startsLine = indentation.trim() === "";
+    const declarations = replacements.map(({ node, name }) => `const ${name} = ${rewrite(node.range, node)}`);
+    const remainder = rewrite(statement.range);
+    const guarded = startsLine && /^[[(`+\-/]/.test(remainder) ? `;${remainder}` : remainder;
+    return [...declarations, guarded].join(startsLine ? `\n${indentation}` : "; ");
+};
+export const noInlineYieldStarRule = defineRule({
+    meta: {
+        type: "suggestion",
+        fixable: "code",
+        docs: {
+            description: "Bind the result of a `yield*` to a `const` instead of using it inside a larger expression.",
+        },
+        messages: {
+            inlineYieldStar: "This `yield*` runs inside a larger expression. Bind its result first (`const rows = yield* reader.rows`), so each statement runs one effect in reading order.",
+        },
+    },
+    createOnce(context) {
+        let inline = [];
+        let effectful = [];
+        const collect = (node) => {
+            effectful.push(node);
+        };
+        return {
+            before() {
+                inline = [];
+                effectful = [];
+            },
+            YieldExpression(node) {
+                effectful.push(node);
+                if (node.delegate && !isStandalone(node))
+                    inline.push(node);
+            },
+            AwaitExpression: collect,
+            AssignmentExpression: collect,
+            CallExpression: collect,
+            NewExpression: collect,
+            TaggedTemplateExpression: collect,
+            UpdateExpression: collect,
+            VariableDeclarator: collect,
+            "Program:exit"() {
+                const byStatement = new Map();
+                for (const node of inline) {
+                    const statement = statementOf(node);
+                    byStatement.set(statement, [...(byStatement.get(statement) ?? []), node]);
+                }
+                for (const [statement, yields] of byStatement) {
+                    const owner = nearestFunction(statement);
+                    const hoisted = yields
+                        .filter((node) => canHoist(node, statement))
+                        .toSorted((left, right) => left.range[1] - right.range[1] || right.range[0] - left.range[0]);
+                    const evaluatedInStatement = effectful.filter((node) => contains(statement.range, node.range) &&
+                        nearestFunction(node) === owner);
+                    const fixable = statement.type !== "Program" &&
+                        hoisted.length > 0 &&
+                        !reordersEffects(hoisted, evaluatedInStatement);
+                    const replacement = fixable
+                        ? extraction(statement, hoisted, context.sourceCode)
+                        : undefined;
+                    for (const node of yields) {
+                        context.report({
+                            node,
+                            messageId: "inlineYieldStar",
+                            ...(replacement !== undefined && hoisted.includes(node)
+                                ? { fix: (fixer) => fixer.replaceText(statement, replacement) }
+                                : {}),
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-manual-discriminant-comparison.d.ts

@@ -0,0 +1,2 @@
+export declare const remedyFor: (discriminant: string) => string;
+export declare const noManualDiscriminantComparisonRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-manual-discriminant-comparison.js

@@ -0,0 +1,81 @@
+import { defineRule } from "@oxlint/plugins";
+import { configuredDiscriminants, discriminantOf, discriminantsSchema, isEqualityComparison, isInsideBroadEffectHandler, isStringLiteral, } from "../shared/tagged-values.js";
+export const remedyFor = (discriminant) => discriminant === "_tag"
+    ? "`Match.tagsExhaustive`, the tagged enum `$match` or an exhaustive ts-pattern match; for a single check, `Predicate.isTagged`"
+    : `\`Match.discriminatorsExhaustive("${discriminant}")\` or an exhaustive ts-pattern match`;
+// Effect's own two-variant types cannot gain a variant: their refinements are the remedy.
+const effectVariants = {
+    Success: { owner: "`Result`/`Exit`", guard: "`Result.isSuccess` or `Exit.isSuccess`" },
+    Failure: { owner: "`Result`/`Exit`", guard: "`Result.isFailure` or `Exit.isFailure`" },
+    Left: { owner: "`Either`", guard: "`Either.isLeft`" },
+    Right: { owner: "`Either`", guard: "`Either.isRight`" },
+    Some: { owner: "`Option`", guard: "`Option.isSome`" },
+    None: { owner: "`Option`", guard: "`Option.isNone`" },
+};
+const effectVariantOf = (tag) => Object.hasOwn(effectVariants, tag) ? { tag, ...effectVariants[tag] } : undefined;
+export const noManualDiscriminantComparisonRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Branch on a union's discriminant with an exhaustive match, not with comparisons or `switch`.",
+        },
+        messages: {
+            manualComparison: "Comparing `{{discriminant}}` with a literal still compiles when a variant is added: use {{remedy}}.",
+            effectVariantComparison: 'For the `"{{tag}}"` variant of {{owner}}, use {{guard}}; for a union of your own, {{remedy}}.',
+            manualSwitch: "A `switch` on `{{discriminant}}` still compiles when a variant is added: use {{remedy}}.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { discriminants: discriminantsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let discriminants = new Set();
+        const report = (node, discriminant, messageId, literal) => {
+            // Inside `Effect.catch` handlers, `_tag` belongs to `anti-slop-no-manual-effect-error-tag`.
+            if (discriminant === "_tag" && isInsideBroadEffectHandler(node))
+                return;
+            const remedy = remedyFor(discriminant);
+            const variant = discriminant === "_tag" && literal !== undefined
+                ? effectVariantOf(literal)
+                : undefined;
+            if (variant !== undefined) {
+                context.report({
+                    node,
+                    messageId: "effectVariantComparison",
+                    data: { ...variant, remedy },
+                });
+                return;
+            }
+            context.report({ node, messageId, data: { discriminant, remedy } });
+        };
+        return {
+            before() {
+                discriminants = configuredDiscriminants(context.options);
+            },
+            BinaryExpression(node) {
+                if (!isEqualityComparison(node))
+                    return;
+                const literal = isStringLiteral(node.right)
+                    ? node.right
+                    : isStringLiteral(node.left)
+                        ? node.left
+                        : undefined;
+                if (literal === undefined)
+                    return;
+                const subject = literal === node.right ? node.left : node.right;
+                const discriminant = discriminantOf(subject, discriminants);
+                if (discriminant !== undefined)
+                    report(node, discriminant, "manualComparison", literal.value);
+            },
+            SwitchStatement(node) {
+                const discriminant = discriminantOf(node.discriminant, discriminants);
+                if (discriminant !== undefined)
+                    report(node, discriminant, "manualSwitch");
+            },
+        };
+    },
+});

package/dist/rules/no-manual-discriminant-construction.d.ts

@@ -0,0 +1,2 @@
+export declare const remedyFor: (discriminant: string) => "the Schema's `.make` or the class constructor" | "the Schema's tagged `.make`, the tagged class or error constructor, or the `Data.taggedEnum` variant constructor";
+export declare const noManualDiscriminantConstructionRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-manual-discriminant-construction.js

@@ -0,0 +1,132 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+import { configuredDiscriminants, discriminantsSchema, isStringLiteral, propertyName, } from "../shared/tagged-values.js";
+export const remedyFor = (discriminant) => discriminant === "_tag"
+    ? "the Schema's tagged `.make`, the tagged class or error constructor, or the `Data.taggedEnum` variant constructor"
+    : "the Schema's `.make` or the class constructor";
+const isMatchPatternCall = (call) => {
+    const method = calleeOf(call, "Match");
+    return method === "when" || method === "not";
+};
+// `match(value).with(pattern, handler)`, also after earlier `.with`/`.when` links of the chain.
+const isTsPatternWithCall = (call) => {
+    if (call.callee.type !== "MemberExpression" ||
+        call.callee.computed ||
+        call.callee.property.type !== "Identifier" ||
+        call.callee.property.name !== "with") {
+        return false;
+    }
+    let link = call.callee.object;
+    while (link.type === "CallExpression" && link.callee.type === "MemberExpression") {
+        link = link.callee.object;
+    }
+    return (link.type === "CallExpression" &&
+        link.callee.type === "Identifier" &&
+        link.callee.name === "match");
+};
+// `Schema.decodeUnknownSync(X)(input)`: the literal is raw data to validate, not a value of X.
+const isSchemaCodecApplication = (call) => {
+    const method = calleeOf(call.callee, "Schema");
+    return method !== undefined && (method.startsWith("decode") || method.startsWith("encode"));
+};
+// `expect(x).toMatchObject(…)`, `expect(x).not.toEqual(…)`, `expect.objectContaining(…)`: the
+// literal describes the expected shape, and a partial match has no constructor to call.
+const isAssertionExpectation = (call) => {
+    if (call.callee.type !== "MemberExpression")
+        return false;
+    let link = call.callee;
+    while (link.type === "MemberExpression" || link.type === "CallExpression") {
+        link = link.type === "MemberExpression" ? link.object : link.callee;
+    }
+    return link.type === "Identifier" && link.name === "expect";
+};
+// `JSON.stringify({ _tag: "NotReady" })`: the literal is the serialized form, which no constructor builds.
+const isJsonSerialization = (call) => calleeOf(call, "JSON") === "stringify";
+const declaredFunction = (name, scope) => {
+    for (let current = scope; current; current = current.upper) {
+        const definition = current.set.get(name)?.defs[0];
+        if (definition === undefined)
+            continue;
+        const declared = definition.node.type === "VariableDeclarator" ? definition.node.init : definition.node;
+        return isFunctionNode(declared) ? declared : undefined;
+    }
+    return undefined;
+};
+// `readinessAgainst(503, { _tag: "NotReady" })` with `readinessAgainst` declared in the file as
+// `(status: number, body: unknown) => …`: the author declared the argument raw data, such as the
+// body a fake HTTP server answers with. Without types, a function imported from elsewhere is not seen.
+const isUnknownArgument = (call, argument, sourceCode) => {
+    if (call.callee.type !== "Identifier")
+        return false;
+    const index = call.arguments.findIndex((candidate) => candidate === argument);
+    if (call.arguments.slice(0, index).some((candidate) => candidate.type === "SpreadElement")) {
+        return false;
+    }
+    const fn = declaredFunction(call.callee.name, sourceCode.getScope(call));
+    const parameter = fn?.params[index];
+    const binding = parameter?.type === "AssignmentPattern" ? parameter.left : parameter;
+    return (binding?.type === "Identifier" &&
+        binding.typeAnnotation?.typeAnnotation.type === "TSUnknownKeyword");
+};
+// A literal nested in a pattern, in an expectation or in raw input belongs to it as much as the outermost one.
+const isPatternExpectationOrRawInput = (node, sourceCode) => {
+    let child = node;
+    let current = node.parent;
+    while (current?.type === "Property" ||
+        current?.type === "ObjectExpression" ||
+        current?.type === "ArrayExpression") {
+        child = current;
+        current = current.parent;
+    }
+    return (current?.type === "CallExpression" &&
+        current.arguments.some((argument) => argument === child) &&
+        (isMatchPatternCall(current) ||
+            isTsPatternWithCall(current) ||
+            isAssertionExpectation(current) ||
+            isSchemaCodecApplication(current) ||
+            isJsonSerialization(current) ||
+            isUnknownArgument(current, child, sourceCode)));
+};
+export const noManualDiscriminantConstructionRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Construct a union's variants with their constructor, not as object literals with the discriminant.",
+        },
+        messages: {
+            manualConstruction: "An object literal with a literal `{{discriminant}}` skips the variant's constructor: use {{remedy}}.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { discriminants: discriminantsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let discriminants = new Set();
+        return {
+            before() {
+                discriminants = configuredDiscriminants(context.options);
+            },
+            ObjectExpression(node) {
+                for (const property of node.properties) {
+                    if (property.type !== "Property" || !isStringLiteral(property.value))
+                        continue;
+                    const discriminant = propertyName(property);
+                    if (discriminant === undefined || !discriminants.has(discriminant))
+                        continue;
+                    if (isPatternExpectationOrRawInput(node, context.sourceCode))
+                        return;
+                    context.report({
+                        node: property,
+                        messageId: "manualConstruction",
+                        data: { discriminant, remedy: remedyFor(discriminant) },
+                    });
+                    return;
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-nested-match.d.ts

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

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

@@ -0,0 +1,24 @@
+import { defineRule } from "@oxlint/plugins";
+import { handlersOf, isMatchCall, nestedBranches } from "../shared/match-ast.js";
+export const noNestedMatchRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Flatten a match whose handler branches again: a guard clause inside generators, a named handler outside.",
+        },
+        messages: {
+            nestedBranch: "This handler branches again inside a match. Inside a generator, return early on the exit case (`if (Result.isFailure(parsed)) return yield* ...`); outside, name the inner choice and pass it as the handler.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (!isMatchCall(node))
+                    return;
+                for (const branch of handlersOf(node).flatMap(nestedBranches)) {
+                    context.report({ node: branch, messageId: "nestedBranch" });
+                }
+            },
+        };
+    },
+});

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

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

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

@@ -0,0 +1,29 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+const catchAlls = new Set(["catch", "catchAll", "catchCause", "catchEager"]);
+export const noParameterlessCatchAllRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Forbid catch-all handlers that ignore the error they catch.",
+        },
+        messages: {
+            swallowed: "`Effect.{{name}}` ignores what it catches, so it also swallows failures added later: use `Effect.catchTag`, or `Effect.orElseSucceed`/`Effect.orElse` when every failure truly means the same fallback.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const name = calleeOf(node, "Effect");
+                if (name === undefined || !catchAlls.has(name))
+                    return;
+                const handler = node.arguments.at(-1);
+                if ((handler?.type === "ArrowFunctionExpression" ||
+                    handler?.type === "FunctionExpression") &&
+                    handler.params.length === 0) {
+                    context.report({ node: handler, messageId: "swallowed", data: { name } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-provide-on-definition.d.ts

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

package/dist/rules/no-provide-on-definition.js

@@ -0,0 +1,123 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isEffectFnApplication } from "../shared/effect-ast.js";
+import { runnerName } from "../shared/effect-runners.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+const pipeReceiver = (call) => {
+    const { callee } = call;
+    return callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "pipe"
+        ? callee.object
+        : undefined;
+};
+const isProgramDefinition = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    if (calleeOf(node, "Effect") === "gen" || isEffectFnApplication(node))
+        return true;
+    return isProgramDefinition(pipeReceiver(node));
+};
+const isContextCapture = (init) => {
+    if (init?.type !== "YieldExpression" || !init.delegate)
+        return false;
+    let source = init.argument;
+    while (source?.type === "CallExpression" && pipeReceiver(source))
+        source = pipeReceiver(source);
+    return calleeOf(source, "Effect") === "context";
+};
+const isCapturedContext = (value) => {
+    if (value?.type !== "Identifier")
+        return false;
+    for (let current = value.parent; current; current = current.parent) {
+        if (current.type !== "BlockStatement")
+            continue;
+        const captured = current.body.some((statement) => statement.type === "VariableDeclaration" &&
+            statement.kind === "const" &&
+            statement.declarations.some((declarator) => declarator.id.type === "Identifier" &&
+                declarator.id.name === value.name &&
+                isContextCapture(declarator.init)));
+        if (captured)
+            return true;
+    }
+    return false;
+};
+const providedValue = (provide) => provide.arguments[provide.arguments.length > 1 ? 1 : 0];
+const providedDefinition = (provide) => {
+    if (provide.arguments.length > 1)
+        return isProgramDefinition(provide.arguments[0]);
+    const parent = provide.parent;
+    if (parent?.type !== "CallExpression")
+        return false;
+    // `Effect.fn("name")(body, Effect.provide(layer))`: the pipeable slot belongs to the definition.
+    if (isEffectFnApplication(parent) && parent.arguments.indexOf(provide) > 0)
+        return true;
+    return parent.arguments.includes(provide) && isProgramDefinition(pipeReceiver(parent));
+};
+const isRunnerCall = (node) => node?.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    runnerName(node.callee) !== undefined;
+// The expression a `.pipe(…)` or a data-first `Effect.*` combinator builds around `node`.
+const enclosingProgram = (node) => {
+    const { parent } = node;
+    if (parent?.type === "MemberExpression" && parent.object === node) {
+        const call = parent.parent;
+        return call?.type === "CallExpression" && pipeReceiver(call) === node ? call : undefined;
+    }
+    return parent?.type === "CallExpression" &&
+        parent.arguments.some((argument) => argument === node) &&
+        (pipeReceiver(parent) !== undefined || calleeOf(parent, "Effect") !== undefined) &&
+        !isRunnerCall(parent)
+        ? parent
+        : undefined;
+};
+// A program handed straight to `Effect.run*` has no caller to wire it: it is being dispatched.
+const isDispatchedInline = (provide) => {
+    let program = provide;
+    for (let outer = enclosingProgram(program); outer; outer = enclosingProgram(program)) {
+        program = outer;
+    }
+    const { parent } = program;
+    return isRunnerCall(parent) && parent.arguments.some((argument) => argument === program);
+};
+// A program that provides its own layers can no longer be wired differently by its caller:
+// the dispatch that picks the adapters is where `Effect.provide` belongs.
+export const noProvideOnDefinitionRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Keep `Effect.provide` off `Effect.gen`/`Effect.fn` definitions; provide where the program is dispatched. Test files are skipped.",
+        },
+        messages: {
+            provideOnDefinition: "Define the program without layers and apply `Effect.provide` where it is dispatched, to a named program.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // `it.effect(…, () => Effect.gen(…).pipe(Effect.provide(fakes)))` is the idiomatic test.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            CallExpression(node) {
+                if (inTestFile || calleeOf(node, "Effect") !== "provide")
+                    return;
+                // A Layer that captures its context with `Effect.context()` hands it back to each
+                // method: the caller already chose the adapters when it built the Layer.
+                if (providedDefinition(node) &&
+                    !isCapturedContext(providedValue(node)) &&
+                    !isDispatchedInline(node)) {
+                    context.report({ node, messageId: "provideOnDefinition" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-transport-types-in-generator.d.ts

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