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

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export { defaultEntryFiles } from "./shared/entry-files.ts";
+export { defaultDiscriminants } from "./shared/tagged-values.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;

package/dist/index.js

@@ -1,14 +1,12 @@
 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 { boundaryEntrypointShapeRule } from "./rules/boundary-entrypoint-shape.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";
@@ -18,18 +16,24 @@ import { noManualDiscriminantConstructionRule } from "./rules/no-manual-discrimi
 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 { noThrowOrPrimitiveFailureRule } from "./rules/no-throw-or-primitive-failure.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 { runOnlyAtEntryRule } from "./rules/run-only-at-entry.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 { splitSuccessPathFromErrorHandlingRule } from "./rules/split-success-path-from-error-handling.js";
 import { tryObjectFormRule } from "./rules/try-object-form.js";
 import { untracedRecursionRule } from "./rules/untraced-recursion.js";
+export { defaultEntryFiles } from "./shared/entry-files.js";
+export { defaultDiscriminants } from "./shared/tagged-values.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);
@@ -40,11 +44,11 @@ const dlEffectPlugin = eslintCompatPlugin({
         "anti-slop-no-service-constructor-imports": antiSlopNoServiceConstructorImportsRule,
         "anti-slop-prefer-effect-match": antiSlopPreferEffectMatchRule,
         "adapter-import-boundary": adapterImportBoundaryRule,
-        "boundary-entrypoint-shape": boundaryEntrypointShapeRule,
-        "error-handling-in-effect-fn-handler": errorHandlingInEffectFnHandlerRule,
+        "all-errors-handled-at-boundary": allErrorsHandledAtBoundaryRule,
+        "split-success-path-from-error-handling": splitSuccessPathFromErrorHandlingRule,
         "exported-schema-identifier": exportedSchemaIdentifierRule,
         "no-asymmetric-match-handlers": noAsymmetricMatchHandlersRule,
-        "no-bare-error-in-effect": noBareErrorInEffectRule,
+        "no-throw-or-primitive-failure": noThrowOrPrimitiveFailureRule,
         "no-effect-promise": noEffectPromiseRule,
         "no-effect-return-type": noEffectReturnTypeRule,
         "no-inline-schema-codec": noInlineSchemaCodecRule,
@@ -57,9 +61,10 @@ const dlEffectPlugin = eslintCompatPlugin({
         "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-at-entry": runOnlyAtEntryRule,
+        "run-only-in-runner": runOnlyInRunnerRule,
         "service-built-with-of": serviceBuiltWithOfRule,
         "service-key-matches-name": serviceKeyMatchesNameRule,
         "service-port-shape-only": servicePortShapeOnlyRule,

package/dist/presets/all.json

@@ -7,11 +7,11 @@
         "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/boundary-entrypoint-shape": "warn",
-        "dl-effect/error-handling-in-effect-fn-handler": "warn",
+        "dl-effect/all-errors-handled-at-boundary": "warn",
+        "dl-effect/split-success-path-from-error-handling": "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-throw-or-primitive-failure": "warn",
         "dl-effect/no-effect-promise": "warn",
         "dl-effect/no-effect-return-type": "warn",
         "dl-effect/no-inline-schema-codec": "warn",
@@ -24,9 +24,10 @@
         "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-at-entry": "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",

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

@@ -2,7 +2,6 @@ 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
@@ -28,7 +27,10 @@ const LAYER_CONSTRUCTORS = [
 ];
 // 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);
+// An Effect 3 `Effect.Service` always carries its implementation and the `Default` layer built
+// from it, so a file that declares one is an adapter even without a `Layer.*` call.
+const EFFECT_SERVICE = /\bEffect\.Service\s*[<(]/u;
+export const buildsLayer = (source) => LAYER_CONSTRUCTION.test(source) || EFFECT_SERVICE.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) => {
@@ -64,16 +66,7 @@ export const makeAdapterImportBoundaryRule = (deps) => defineRule({
             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,
-            },
-        ],
+        schema: [],
     },
     create(context) {
         const ownDir = dirname(context.filename);

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,105 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isServerComponent, memberOf, nearestFunction, } from "../shared/effect-ast.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.
+// `either` is the Effect 3 name of `result`.
+const failureToValue = new Set(["result", "either", "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: [],
+    },
+    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-service-constructor-imports.js

@@ -1,5 +1,4 @@
 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("../");
@@ -13,13 +12,7 @@ export const antiSlopNoServiceConstructorImportsRule = defineRule({
         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,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;

package/dist/rules/exported-schema-identifier.js

@@ -8,6 +8,13 @@ const chainedMethod = (node) => node.type === "CallExpression" &&
     node.callee.property.type === "Identifier"
     ? { name: node.callee.property.name, receiver: node.callee.object, call: node }
     : undefined;
+// `annotations` is the Effect 3 name of `annotate`.
+const isAnnotate = (name) => name === "annotate" || name === "annotations";
+// One suggestion per version instead of detecting the installed one: the fix stays syntax only.
+const annotateMethods = [
+    { version: "v3", method: "annotations" },
+    { version: "v4", method: "annotate" },
+];
 // `X.pipe(Schema.annotate(a))` and `X.annotate(a)`, in any order along the chain.
 const annotationsOf = (init) => {
     const annotations = [];
@@ -16,11 +23,11 @@ const annotationsOf = (init) => {
         const link = chainedMethod(current);
         if (link === undefined)
             return undefined;
-        if (link.name === "annotate")
+        if (isAnnotate(link.name))
             annotations.push(...link.call.arguments);
         else if (link.name === "pipe") {
             for (const argument of link.call.arguments) {
-                if (calleeOf(argument, "Schema") === "annotate" &&
+                if (isAnnotate(calleeOf(argument, "Schema")) &&
                     argument.type === "CallExpression") {
                     annotations.push(...argument.arguments);
                 }
@@ -58,7 +65,7 @@ export const exportedSchemaIdentifierRule = defineRule({
         messages: {
             missingIdentifier: 'Annotate `{{name}}` with `identifier: "{{name}}"`, so errors, JSON Schema and arbitraries name it.',
             wrongIdentifier: 'The `identifier` of `{{name}}` is `{{identifier}}`: use `"{{name}}"`, the name the schema is imported by.',
-            addIdentifier: 'Append `.annotate({ identifier: "{{name}}" })`.',
+            addIdentifier: '{{version}}: append `.{{method}}({ identifier: "{{name}}" })`.',
             renameIdentifier: 'Use `"{{name}}"` as identifier.',
         },
     },
@@ -77,13 +84,11 @@ export const exportedSchemaIdentifierRule = defineRule({
                     node: id,
                     messageId: "missingIdentifier",
                     data: { name },
-                    suggest: [
-                        {
-                            messageId: "addIdentifier",
-                            data: { name },
-                            fix: (fixer) => fixer.insertTextAfter(init, `.annotate({ identifier: "${name}" })`),
-                        },
-                    ],
+                    suggest: annotateMethods.map(({ version, method }) => ({
+                        messageId: "addIdentifier",
+                        data: { name, version, method },
+                        fix: (fixer) => fixer.insertTextAfter(init, `.${method}({ identifier: "${name}" })`),
+                    })),
                 });
                 return;
             }

package/dist/rules/no-effect-promise.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";
 // Argument index of the release step, where a promise that cannot reject is the normal case.
 const releaseSlots = new Map([
@@ -30,13 +29,7 @@ export const noEffectPromiseRule = defineRule({
         messages: {
             rejectionAsDefect: "`Effect.promise` turns a rejection into a defect: use `Effect.tryPromise({ try, catch })` unless the promise cannot reject.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;

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

@@ -1,8 +1,18 @@
 import { defineRule } from "@oxlint/plugins";
-import { configuredDiscriminants, discriminantOf, discriminantsSchema, isEqualityComparison, isInsideBroadEffectHandler, isStringLiteral, } from "../shared/tagged-values.js";
+import { configuredDiscriminants, discriminantOf, 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",
@@ -11,42 +21,49 @@ export const noManualDiscriminantComparisonRule = defineRule({
         },
         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,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let discriminants = new Set();
-        const report = (node, discriminant, messageId) => {
+        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;
-            context.report({
-                node,
-                messageId,
-                data: { discriminant, remedy: remedyFor(discriminant) },
-            });
+            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);
+                discriminants = configuredDiscriminants(context.settings);
             },
             BinaryExpression(node) {
                 if (!isEqualityComparison(node))
                     return;
-                const discriminant = isStringLiteral(node.right)
-                    ? discriminantOf(node.left, discriminants)
+                const literal = isStringLiteral(node.right)
+                    ? node.right
                     : isStringLiteral(node.left)
-                        ? discriminantOf(node.right, discriminants)
+                        ? 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");
+                    report(node, discriminant, "manualComparison", literal.value);
             },
             SwitchStatement(node) {
                 const discriminant = discriminantOf(node.discriminant, discriminants);

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

@@ -1,6 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
-import { calleeOf } from "../shared/effect-ast.js";
-import { configuredDiscriminants, discriminantsSchema, isStringLiteral, propertyName, } from "../shared/tagged-values.js";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+import { configuredDiscriminants, 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";
@@ -29,8 +29,47 @@ const isSchemaCodecApplication = (call) => {
     const method = calleeOf(call.callee, "Schema");
     return method !== undefined && (method.startsWith("decode") || method.startsWith("encode"));
 };
-// A literal nested in a pattern or in a codec input belongs to it as much as the outermost one.
-const isPatternOrCodecInput = (node) => {
+// `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" ||
@@ -43,7 +82,10 @@ const isPatternOrCodecInput = (node) => {
         current.arguments.some((argument) => argument === child) &&
         (isMatchPatternCall(current) ||
             isTsPatternWithCall(current) ||
-            isSchemaCodecApplication(current)));
+            isAssertionExpectation(current) ||
+            isSchemaCodecApplication(current) ||
+            isJsonSerialization(current) ||
+            isUnknownArgument(current, child, sourceCode)));
 };
 export const noManualDiscriminantConstructionRule = defineRule({
     meta: {
@@ -54,19 +96,13 @@ export const noManualDiscriminantConstructionRule = defineRule({
         messages: {
             manualConstruction: "An object literal with a literal `{{discriminant}}` skips the variant's constructor: use {{remedy}}.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { discriminants: discriminantsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let discriminants = new Set();
         return {
             before() {
-                discriminants = configuredDiscriminants(context.options);
+                discriminants = configuredDiscriminants(context.settings);
             },
             ObjectExpression(node) {
                 for (const property of node.properties) {
@@ -75,7 +111,7 @@ export const noManualDiscriminantConstructionRule = defineRule({
                     const discriminant = propertyName(property);
                     if (discriminant === undefined || !discriminants.has(discriminant))
                         continue;
-                    if (isPatternOrCodecInput(node))
+                    if (isPatternExpectationOrRawInput(node, context.sourceCode))
                         return;
                     context.report({
                         node: property,

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

@@ -1,6 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, isEffectFnApplication } from "../shared/effect-ast.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
+import { runnerName } from "../shared/effect-runners.js";
 import { isTestFile } from "../shared/test-files.js";
 const pipeReceiver = (call) => {
     const { callee } = call;
@@ -54,6 +54,32 @@ const providedDefinition = (provide) => {
         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({
@@ -65,13 +91,7 @@ export const noProvideOnDefinitionRule = defineRule({
         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,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;
@@ -85,7 +105,9 @@ export const noProvideOnDefinitionRule = defineRule({
                     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))) {
+                if (providedDefinition(node) &&
+                    !isCapturedContext(providedValue(node)) &&
+                    !isDispatchedInline(node)) {
                     context.report({ node, messageId: "provideOnDefinition" });
                 }
             },

package/dist/rules/no-throw-or-primitive-failure.d.ts

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