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

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 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;

package/dist/index.js

@@ -5,10 +5,8 @@ import { allErrorsHandledAtBoundaryRule } from "./rules/all-errors-handled-at-bo
 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";
@@ -18,6 +16,7 @@ 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";
@@ -29,9 +28,11 @@ 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/`.
@@ -44,10 +45,10 @@ const dlEffectPlugin = eslintCompatPlugin({
         "anti-slop-prefer-effect-match": antiSlopPreferEffectMatchRule,
         "adapter-import-boundary": adapterImportBoundaryRule,
         "all-errors-handled-at-boundary": allErrorsHandledAtBoundaryRule,
-        "error-handling-in-effect-fn-handler": errorHandlingInEffectFnHandlerRule,
+        "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,

package/dist/presets/all.json

@@ -8,10 +8,10 @@
         "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/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",

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.js

@@ -1,6 +1,5 @@
 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
@@ -26,7 +25,8 @@ const parameterType = (identifier) => {
     return undefined;
 };
 // They turn every failure into a success value, so whatever comes before cannot leak.
-const failureToValue = new Set(["result", "exit"]);
+// `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" &&
@@ -55,13 +55,7 @@ export const allErrorsHandledAtBoundaryRule = defineRule({
         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,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         const frames = [];

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,5 +1,5 @@
 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`;
@@ -24,13 +24,7 @@ export const noManualDiscriminantComparisonRule = defineRule({
             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();
@@ -54,7 +48,7 @@ export const noManualDiscriminantComparisonRule = defineRule({
         };
         return {
             before() {
-                discriminants = configuredDiscriminants(context.options);
+                discriminants = configuredDiscriminants(context.settings);
             },
             BinaryExpression(node) {
                 if (!isEqualityComparison(node))

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

@@ -1,6 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
-import { configuredDiscriminants, discriminantsSchema, isStringLiteral, propertyName, } from "../shared/tagged-values.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";
@@ -96,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) {

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

@@ -1,7 +1,6 @@
 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;
@@ -92,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;

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

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

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

@@ -1,10 +1,9 @@
 import { defineRule } from "@oxlint/plugins";
 import { calleeOf, isEffectGenerator, nearestFunction } from "../shared/effect-ast.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
 import { isTestFile } from "../shared/test-files.js";
 // Only the two forms the effecttsgo preset misses: `Effect.fail(new Error(…))` and
 // `extends Error` are already reported by global-error-in-effect-failure and extends-native-error.
-export const noBareErrorInEffectRule = defineRule({
+export const noThrowOrPrimitiveFailureRule = defineRule({
     meta: {
         type: "problem",
         docs: {
@@ -14,13 +13,7 @@ export const noBareErrorInEffectRule = defineRule({
             throwInGenerator: "A `throw` inside an Effect generator becomes a defect: `return yield* new TaggedError(...)` instead.",
             primitiveFailure: "Fail with a tagged error (`Data.TaggedError` or `Schema.TaggedError`), not a primitive value.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let inTestFile = false;

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

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

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

@@ -2,7 +2,6 @@ import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { defineRule } from "@oxlint/plugins";
 import { runnerName } from "../shared/effect-runners.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
 import { isTestFile } from "../shared/test-files.js";
 // Without `@effect/vitest` the remedy is out of reach, so the rule stays silent. Not cached:
 // a long-lived linter would miss a later install, and only test files pay for the lookup.
@@ -24,13 +23,7 @@ export const preferEffectVitestRule = defineRule({
         messages: {
             runInTest: "`{{name}}` runs an Effect program in a test: let `@effect/vitest` run it, so the test gets the test runtime and its fixtures become Layers.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let checked = false;

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

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

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

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

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

@@ -1,7 +1,6 @@
 import { defineRule } from "@oxlint/plugins";
 import { runnerName } from "../shared/effect-runners.js";
 import { isEntryFile } from "../shared/entry-files.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
 import { isTestFile } from "../shared/test-files.js";
 // Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
 export const runOnlyInRunnerRule = defineRule({
@@ -13,13 +12,7 @@ export const runOnlyInRunnerRule = defineRule({
         messages: {
             runOutsideEntry: "`{{name}}` runs an Effect program: only the entry point may do that.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { entryFiles: filePatternsSchema, testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         let skipped = false;

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

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

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

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

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

@@ -1,6 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
 import { isEffectGenerator, isServerComponent, memberOf, } from "../shared/effect-ast.js";
-import { filePatternsSchema } from "../shared/file-globs.js";
 import { isTestFile } from "../shared/test-files.js";
 const isThenCall = (node) => node.callee.type === "MemberExpression" &&
     !node.callee.computed &&
@@ -49,13 +48,7 @@ export const singleStylePerFunctionRule = defineRule({
             asyncEffectHook: "This hook chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`, or build the fixture as a Layer with `layer` from `@effect/vitest`.",
             asyncEffectHelper: "This test helper chains promises around Effect: await a single program, lifting the promises into it with `Effect.tryPromise({ try, catch })`.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: { testFiles: filePatternsSchema },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
     createOnce(context) {
         const frames = [];

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

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