oxlint-plugin-effect 0.1.0 → 0.2.1

package/src/rules/no-global-error-in-catch.ts

@@ -1,104 +0,0 @@
-/**
- * Ban `new Error()` inside Effect catch handlers.
- *
- * Catches: `.catchAll(e => new Error(...))`, `.catch(e => new Error(...))`
- * Use Schema.TaggedErrorClass or Data.TaggedError instead.
- *
- * Source: language-service/globalErrorInEffectCatch
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-const nativeErrors = new Set([
-  "Error",
-  "TypeError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "URIError",
-  "EvalError",
-])
-
-const catchMethods = new Set([
-  "catch",
-  "catchAll",
-  "catchAllCause",
-  "catchIf",
-  "catchCauseIf",
-  "catchTag",
-  "catchTags",
-  "catchDefect",
-])
-
-const isNativeErrorNew = (node: ESTree.Node): boolean => {
-  if (node.type !== "NewExpression") return false
-  const callee = (node as unknown as Record<string, unknown>)["callee"] as ESTree.Node
-  return callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name as string)
-}
-
-/**
- * Check if a function body returns `new Error(...)`.
- */
-const bodyReturnsNativeError = (fn: ESTree.Node): boolean => {
-  const body = (fn as unknown as Record<string, unknown>)["body"] as ESTree.Node
-  // Arrow expression body: (e) => new Error(...)
-  if (body.type !== "BlockStatement") {
-    return isNativeErrorNew(body)
-  }
-  // Block body: (e) => { return new Error(...) }
-  const stmts = (body as unknown as Record<string, unknown>)["body"]
-  if (!Array.isArray(stmts) || stmts.length !== 1) return false
-  const stmt = stmts[0] as ESTree.Node
-  if (stmt.type !== "ReturnStatement") return false
-  const arg = (stmt as unknown as Record<string, unknown>)["argument"]
-  return arg != null && typeof arg === "object" && isNativeErrorNew(arg as ESTree.Node)
-}
-
-export const noGlobalErrorInCatch = Rule.define({
-  name: "no-global-error-in-catch",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid native Error in Effect catch handlers. Use Schema.TaggedErrorClass or Data.TaggedError.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        const names = Option.getOrUndefined(
-          AST.memberNames(call.callee as ESTree.MemberExpression),
-        )
-        if (names === undefined) return Effect.void
-        const [obj, prop] = names
-        if (obj !== "Effect") return Effect.void
-        if (!catchMethods.has(prop)) return Effect.void
-
-        // The callback is the last argument
-        const args = call.arguments
-        if (args.length === 0) return Effect.void
-        const callback = args[args.length - 1]
-        if (callback === undefined) return Effect.void
-        if (
-          callback.type !== "ArrowFunctionExpression" &&
-          callback.type !== "FunctionExpression"
-        ) {
-          return Effect.void
-        }
-
-        if (bodyReturnsNativeError(callback as ESTree.Node)) {
-          return ctx.report(
-            Diagnostic.make({
-              node: callback,
-              message:
-                "Avoid native Error in Effect catch handler. Use Schema.TaggedErrorClass or Data.TaggedError.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-global-error-in-failure.ts

@@ -1,83 +0,0 @@
-/**
- * Ban `new Error()` inside `Effect.fail()`.
- *
- * Use Schema.TaggedErrorClass or Data.TaggedError instead.
- *
- * Source: language-service/globalErrorInEffectFailure
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-const nativeErrors = new Set([
-  "Error",
-  "TypeError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "URIError",
-  "EvalError",
-])
-
-const isNativeErrorNew = (node: ESTree.Node): boolean => {
-  if (node.type !== "NewExpression") return false
-  const callee = (node as unknown as Record<string, unknown>)["callee"] as ESTree.Node
-  return callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name as string)
-}
-
-export const noGlobalErrorInFailure = Rule.define({
-  name: "no-global-error-in-failure",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid native Error in Effect.fail(). Use Schema.TaggedErrorClass or Data.TaggedError.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const call = node as ESTree.CallExpression
-        if (
-          Option.isNone(AST.matchCallOf(call, "Effect", "fail")) &&
-          Option.isNone(AST.matchCallOf(call, "Effect", "failSync")) &&
-          Option.isNone(AST.matchCallOf(call, "Effect", "failCause"))
-        ) {
-          return Effect.void
-        }
-
-        const args = call.arguments
-        if (args.length === 0) return Effect.void
-
-        // Check direct arg: Effect.fail(new Error(...))
-        const arg = args[args.length - 1]
-        if (arg === undefined) return Effect.void
-        if (isNativeErrorNew(arg as ESTree.Node)) {
-          return ctx.report(
-            Diagnostic.make({
-              node: arg,
-              message:
-                "Avoid native Error in Effect.fail(). Use Schema.TaggedErrorClass or Data.TaggedError.",
-            }),
-          )
-        }
-
-        // Check arrow body: Effect.failSync(() => new Error(...))
-        if (arg.type === "ArrowFunctionExpression") {
-          const body = (arg as unknown as Record<string, unknown>)["body"] as ESTree.Node
-          if (body.type !== "BlockStatement" && isNativeErrorNew(body)) {
-            return ctx.report(
-              Diagnostic.make({
-                node: arg,
-                message:
-                  "Avoid native Error in Effect.failSync(). Use Schema.TaggedErrorClass or Data.TaggedError.",
-              }),
-            )
-          }
-        }
-
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-globals.ts

@@ -1,178 +0,0 @@
-/**
- * Ban global/platform APIs inside Effect.gen/fn context.
- *
- * Consolidates: console, fetch(), Date/new Date, Math.random/crypto,
- * setTimeout/setInterval, JSON.parse/stringify, process/Bun/Deno globals
- *
- * Each has a specific Effect alternative hint.
- *
- * Sources: language-service globalConsoleInEffect, globalFetchInEffect,
- * globalDateInEffect, globalRandomInEffect, globalTimersInEffect,
- * preferSchemaOverJson, processEnvInEffect, cryptoRandomUUIDInEffect
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-// --- Member expression bans (obj.prop) ---
-
-type MemberBan = readonly [obj: string, props: string | ReadonlyArray<string>, message: string]
-
-const memberBans: ReadonlyArray<MemberBan> = [
-  // console
-  ["console", ["log", "warn", "error", "info", "debug", "trace"], "Avoid console.* inside Effect context. Use Effect.log / Effect.logWarning / Effect.logError."],
-  // Date
-  ["Date", "now", "Avoid Date.now() inside Effect context. Use Clock service from 'effect'."],
-  // JSON
-  ["JSON", ["parse", "stringify"], "Avoid JSON.parse/stringify inside Effect context. Use Schema.fromJsonString."],
-  // Math.random
-  ["Math", "random", "Avoid Math.random() inside Effect context. Use Random service from 'effect'."],
-  // crypto
-  ["crypto", ["randomUUID", "getRandomValues"], "Avoid crypto.randomUUID() inside Effect context. Use Random service from 'effect'."],
-]
-
-// --- Platform globals (Bun.*, process.*, Deno.*) ---
-
-const platformObjects = new Set(["Bun", "process", "Deno"])
-
-const alternatives: Record<string, Record<string, string>> = {
-  Bun: {
-    file: "Use FileSystem from 'effect'",
-    write: "Use FileSystem from 'effect'",
-    read: "Use FileSystem from 'effect'",
-    serve: "Use HttpServer from 'effect/unstable/http'",
-    env: "Use Config from 'effect'",
-    spawn: "Use Command from 'effect'",
-    sleep: "Use Effect.sleep",
-    stdin: "Use Terminal from 'effect'",
-    stdout: "Use Terminal from 'effect'",
-    stderr: "Use Terminal from 'effect'",
-    cwd: "Use Path from 'effect'",
-    which: "Use Command from 'effect'",
-    resolveSync: "Use Path from 'effect'",
-    pathToFileURL: "Use Path from 'effect'",
-    randomUUID: "Use Random service from 'effect'",
-    randomUUIDv7: "Use Random service from 'effect'",
-  },
-  process: {
-    env: "Use Config from 'effect'",
-    exit: "Use Effect.fail or Effect.die",
-    cwd: "Use Path from 'effect'",
-    argv: "Use Args/Command from 'effect/unstable/cli'",
-    stdin: "Use Terminal from 'effect'",
-    stdout: "Use Terminal from 'effect'",
-    stderr: "Use Terminal from 'effect'",
-    chdir: "Use Path from 'effect'",
-    kill: "Use Command from 'effect'",
-    on: "Use Effect.async or Stream.async",
-    platform: "Use PlatformInfo from 'effect'",
-    arch: "Use PlatformInfo from 'effect'",
-    execPath: "Use Command from 'effect'",
-    execArgv: "Use Args/Command from 'effect/unstable/cli'",
-  },
-  Deno: {
-    readFile: "Use FileSystem from 'effect'",
-    writeFile: "Use FileSystem from 'effect'",
-    readTextFile: "Use FileSystem from 'effect'",
-    writeTextFile: "Use FileSystem from 'effect'",
-    open: "Use FileSystem from 'effect'",
-    remove: "Use FileSystem from 'effect'",
-    mkdir: "Use FileSystem from 'effect'",
-    readDir: "Use FileSystem from 'effect'",
-    stat: "Use FileSystem from 'effect'",
-    cwd: "Use Path from 'effect'",
-    env: "Use Config from 'effect'",
-    exit: "Use Effect.fail or Effect.die",
-    serve: "Use HttpServer from 'effect/unstable/http'",
-    run: "Use Command from 'effect'",
-    args: "Use Args/Command from 'effect/unstable/cli'",
-  },
-}
-
-function getHint(obj: string, prop: string): string {
-  const hint = alternatives[obj]?.[prop]
-  if (hint) return `. ${hint}`
-  return ". Wrap in a service for testability"
-}
-
-// --- Call expression bans (bare function calls) ---
-
-const callBans: Record<string, string> = {
-  fetch: "Avoid fetch() inside Effect context. Use HttpClient from 'effect/unstable/http'.",
-  setTimeout: "Avoid setTimeout inside Effect context. Use Effect.sleep or Schedule.",
-  setInterval: "Avoid setInterval inside Effect context. Use Effect.sleep or Schedule.",
-}
-
-export const noGlobals = Rule.define({
-  name: "no-globals",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid global/platform APIs inside Effect.gen/fn. Use Effect platform services instead.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      // Member expressions: console.log, Date.now, JSON.parse, Math.random, process.env, Bun.*, etc.
-      MemberExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d <= 0) return Effect.void
-          const memberNode = node as ESTree.MemberExpression
-
-          // Check specific member bans
-          for (const [obj, props, message] of memberBans) {
-            if (Option.isSome(AST.matchMember(memberNode, obj, props))) {
-              return ctx.report(Diagnostic.make({ node, message }))
-            }
-          }
-
-          // Check platform globals (Bun.*, process.*, Deno.*)
-          const names = Option.getOrUndefined(AST.memberNames(memberNode))
-          if (names !== undefined) {
-            const [obj, prop] = names
-            if (platformObjects.has(obj)) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message: `Avoid ${obj}.${prop} inside Effect context${getHint(obj, prop)}.`,
-                }),
-              )
-            }
-          }
-
-          return Effect.void
-        }),
-
-      // Call expressions: fetch(), setTimeout(), setInterval()
-      CallExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d <= 0) return Effect.void
-          const name = Option.getOrUndefined(AST.calleeName(node as ESTree.CallExpression))
-          const message = name !== undefined ? callBans[name] : undefined
-          if (message !== undefined) {
-            return ctx.report(Diagnostic.make({ node, message }))
-          }
-          return Effect.void
-        }),
-
-      // New expressions: new Date()
-      NewExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d <= 0) return Effect.void
-          const callee = (node as unknown as Record<string, unknown>)["callee"] as ESTree.Node
-          if (callee.type === "Identifier" && "name" in callee && callee.name === "Date") {
-            return ctx.report(
-              Diagnostic.make({ node, message: "Avoid new Date() inside Effect context. Use Clock service from 'effect'." }),
-            )
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-if-statement.ts

@@ -1,16 +0,0 @@
-/**
- * Ban `if` statements in Effect codebases.
- *
- * Use `Option.match`, `Either.match`, `Match.value`, or data combinators.
- *
- * Source: biome-effect-linting-rules/no-if-statement
- *
- * Note: Very opinionated — recommended for strict functional presets only.
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noIfStatement = Rule.banStatement("IfStatement", {
-  message:
-    "Avoid if statements. Use Option.match, Either.match, Match.value, or Effect.if.",
-  meta: { type: "suggestion" },
-})

package/src/rules/no-iife-wrapper.ts

@@ -1,51 +0,0 @@
-/**
- * Ban immediately-invoked function expressions (IIFEs).
- *
- * Use named const binding + flat pipeline.
- *
- * Source: biome-effect-linting-rules/no-iife-wrapper
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noIifeWrapper = Rule.define({
-  name: "no-iife-wrapper",
-  meta: Rule.meta({
-    type: "suggestion",
-    description: "Avoid IIFEs. Use named const bindings + flat pipeline.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        if (!("callee" in node)) return Effect.void
-        const callee = node.callee
-        if (callee == null || typeof callee !== "object" || !("type" in callee)) return Effect.void
-
-        const isWrappedFn =
-          callee.type === "ArrowFunctionExpression" ||
-          callee.type === "FunctionExpression"
-
-        // Also catch (expr)(...) where expr is parenthesized fn
-        const isParenWrapped =
-          callee.type === "ParenthesizedExpression" &&
-          "expression" in callee &&
-          callee.expression != null &&
-          typeof callee.expression === "object" &&
-          "type" in callee.expression &&
-          (callee.expression.type === "ArrowFunctionExpression" ||
-            callee.expression.type === "FunctionExpression")
-
-        if (isWrappedFn || isParenWrapped) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Avoid IIFEs. Use named const binding + flat pipeline.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-inline-provide.ts

@@ -1,41 +0,0 @@
-/**
- * Ban `Effect.provide(layer)` used inline inside Effect.gen/fn.
- *
- * Provide layers at the boundary, not deep in generators.
- *
- * Source: biome-effect-linting-rules/no-inline-runtime-provide
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-export const noInlineProvide = Rule.define({
-  name: "no-inline-provide",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      CallExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d <= 0) return Effect.void
-          if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "provide")) return Effect.void
-
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message: "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary.",
-            }),
-          )
-        }),
-    })
-  },
-})

package/src/rules/no-instanceof-schema.ts

@@ -1,42 +0,0 @@
-/**
- * Ban `instanceof` checks against Schema-derived classes.
- *
- * Use `Schema.is(SchemaType)` instead.
- *
- * Source: language-service/instanceOfSchema
- *
- * Note: Without type information, we detect common Effect Schema class names
- * used in `instanceof` checks. This is a best-effort heuristic.
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noInstanceofSchema = Rule.define({
-  name: "no-instanceof-schema",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid instanceof with Schema types. Use Schema.is(SchemaType) instead.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      BinaryExpression: (node) => {
-        if (
-          "operator" in node &&
-          node.operator === "instanceof"
-        ) {
-          // Report all instanceof — in Effect codebases, instanceof is generally wrong
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Avoid instanceof. Add a static `is` field to your class: `static is = Schema.is(this)`, then use `MyClass.is(value)`. For tagged types, use `_tag` checks.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-manual-effect-channels.ts

@@ -1,58 +0,0 @@
-/**
- * Ban manual `Effect.Effect<A, E, R>` type annotations.
- *
- * Let return types infer from the Effect/Layer you return.
- *
- * Source: biome-effect-linting-rules/no-manual-effect-channels
- */
-import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-export const noManualEffectChannels = Rule.define({
-  name: "no-manual-effect-channels",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid manual Effect.Effect<A, E, R> annotations. Let types infer from the returned Effect.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      TSTypeReference: (node) => {
-        if (!("typeName" in node) || node.typeName == null) return Effect.void
-        const typeName = node.typeName as unknown as Record<string, unknown>
-
-        // Effect.Effect<...> or Layer.Layer<...>
-        if (typeName["type"] === "TSQualifiedName" && "left" in typeName && "right" in typeName) {
-          const left = typeName["left"] as unknown as Record<string, unknown> | null
-          const right = typeName["right"] as unknown as Record<string, unknown> | null
-          if (
-            left != null && left["type"] === "Identifier" &&
-            (left["name"] === "Effect" || left["name"] === "Layer") &&
-            right != null && right["type"] === "Identifier" &&
-            (right["name"] === "Effect" || right["name"] === "Layer")
-          ) {
-            // Only flag if explicit type parameters are provided
-            if (
-              "typeParameters" in node &&
-              node.typeParameters != null &&
-              typeof node.typeParameters === "object" &&
-              "params" in (node.typeParameters as unknown as Record<string, unknown>) &&
-              Array.isArray((node.typeParameters as unknown as Record<string, unknown>)["params"]) &&
-              ((node.typeParameters as unknown as Record<string, unknown>)["params"] as unknown[]).length > 0
-            ) {
-              return ctx.report(
-                Diagnostic.make({
-                  node,
-                  message:
-                    "Avoid manual Effect/Layer channel annotations. Let types infer from the returned value.",
-                }),
-              )
-            }
-          }
-        }
-        return Effect.void
-      },
-    }
-  },
-})

package/src/rules/no-match-effect-branch.ts

@@ -1,82 +0,0 @@
-/**
- * Ban Match.when/orElse branches that contain multi-step Effect sequencing.
- *
- * Select the value in Match, then run one Effect pipeline outside.
- *
- * Source: biome-effect-linting-rules/no-match-effect-branch
- */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
-
-const sequencingMethods = new Set(["flatMap", "map", "andThen", "tap", "zipRight", "pipe"])
-
-const containsEffectSequencing = (node: unknown): boolean => {
-  if (node == null || typeof node !== "object") return false
-  const n = node as Record<string, unknown>
-  if (n["type"] === "CallExpression" && "callee" in n) {
-    const callee = n["callee"] as Record<string, unknown> | null
-    if (callee != null && callee["type"] === "MemberExpression") {
-      const obj = callee["object"] as Record<string, unknown> | null
-      const prop = callee["property"] as Record<string, unknown> | null
-      if (
-        obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" &&
-        prop != null && prop["type"] === "Identifier" && typeof prop["name"] === "string" &&
-        sequencingMethods.has(prop["name"])
-      ) {
-        return true
-      }
-    }
-    if ("arguments" in n && Array.isArray(n["arguments"])) {
-      for (const arg of n["arguments"]) {
-        if (containsEffectSequencing(arg)) return true
-      }
-    }
-  }
-  if ("body" in n) {
-    if (Array.isArray(n["body"])) {
-      for (const child of n["body"]) {
-        if (containsEffectSequencing(child)) return true
-      }
-    } else if (containsEffectSequencing(n["body"])) return true
-  }
-  if ("argument" in n && containsEffectSequencing(n["argument"])) return true
-  if ("expression" in n && containsEffectSequencing(n["expression"])) return true
-  return false
-}
-
-export const noMatchEffectBranch = Rule.define({
-  name: "no-match-effect-branch",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Effect sequencing inside Match branches. Select value in Match, run Effect outside.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    return {
-      CallExpression: (node) => {
-        const ce = node as ESTree.CallExpression
-        const isMatchWhen = AST.isCallOf(ce, "Match", "when")
-        const isMatchOrElse = AST.isCallOf(ce, "Match", "orElse")
-
-        if (!isMatchWhen && !isMatchOrElse) return Effect.void
-        if (!("arguments" in node) || !Array.isArray(node.arguments)) return Effect.void
-
-        // Check the callback argument for Effect sequencing
-        const callbackIdx = isMatchWhen ? 1 : 0
-        const callback = node.arguments[callbackIdx]
-        if (callback != null && containsEffectSequencing(callback)) {
-          return ctx.report(
-            Diagnostic.make({
-              node,
-              message:
-                "Avoid Effect sequencing inside Match branches. Select value in Match, then run one Effect pipeline outside.",
-            }),
-          )
-        }
-        return Effect.void
-      },
-    }
-  },
-})