oxlint-plugin-effect 0.0.0 → 0.1.0

package/src/rules/no-effect-map-flatten.ts

@@ -0,0 +1,82 @@
+/**
+ * Ban `.map(f).flatMap(g)` — use `.flatMap(x => g(f(x)))` or refactor.
+ *
+ * Detects `.pipe(Effect.map(f), Effect.flatMap(g))` chains where
+ * the map + flatMap can be fused.
+ *
+ * Source: language-service/effectMapFlatten
+ */
+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 isEffectMap = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "map"))
+}
+
+const isEffectFlatMap = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "flatMap"))
+}
+
+const hasMapFlatMapSequence = (args: ReadonlyArray<ESTree.Node>): boolean => {
+  for (let i = 0; i < args.length - 1; i++) {
+    const a = args[i]; const b = args[i + 1]; if (a && b && isEffectMap(a) && isEffectFlatMap(b)) return true
+  }
+  return false
+}
+
+export const noEffectMapFlatten = Rule.define({
+  name: "no-effect-map-flatten",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect.map followed by Effect.flatMap in pipe. Fuse into a single Effect.flatMap.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const call = node as ESTree.CallExpression
+        const args = call.arguments
+
+        // Bare pipe(value, Effect.map(f), Effect.flatMap(g))
+        const calleeName = Option.getOrUndefined(AST.calleeName(call))
+        if (calleeName === "pipe" && hasMapFlatMapSequence(args as ReadonlyArray<ESTree.Node>)) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Effect.map followed by Effect.flatMap can be fused into a single Effect.flatMap.",
+            }),
+          )
+        }
+
+        // .pipe(Effect.map(f), Effect.flatMap(g))
+        const calleeNode = call.callee
+        if (calleeNode.type === "MemberExpression") {
+          const prop = (calleeNode as unknown as Record<string, unknown>)["property"]
+          if (
+            prop != null &&
+            typeof prop === "object" &&
+            "name" in prop &&
+            prop.name === "pipe" &&
+            hasMapFlatMapSequence(args as ReadonlyArray<ESTree.Node>)
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Effect.map followed by Effect.flatMap can be fused into a single Effect.flatMap.",
+              }),
+            )
+          }
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-effect-map-void.ts

@@ -6,8 +6,7 @@
  * Source: language-service/effectMapVoid
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const isVoidCallback = (arg: unknown): boolean => {

package/src/rules/no-effect-orElse-ladder.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-effect-orElse-ladder
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const sequencingCombinators = ["flatMap", "zipRight", "as", "tap", "andThen"]

package/src/rules/no-effect-succeed-string.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-string-sentinel-return
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noEffectSucceedString = Rule.define({

package/src/rules/no-effect-succeed-variable.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-effect-succeed-variable
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noEffectSucceedVariable = Rule.define({

package/src/rules/no-effect-succeed-void.ts

@@ -6,8 +6,7 @@
  * Source: language-service/effectSucceedWithVoid
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const isUndefinedLike = (node: unknown): boolean => {

package/src/rules/no-effect-sync-console.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-effect-sync-console
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const consoleMethods = new Set(["log", "warn", "error", "info", "debug", "trace"])

package/src/rules/no-effect-sync-wrapper.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/warn-effect-sync-wrapper
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noEffectSyncWrapper = Rule.define({

package/src/rules/no-effect-type-alias.ts

@@ -5,8 +5,7 @@
  *
  * Source: biome-effect-linting-rules/no-effect-type-alias
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const containsEffectType = (node: unknown): boolean => {

package/src/rules/no-effect-wrapper-alias.ts

@@ -5,11 +5,8 @@
  *
  * Source: biome-effect-linting-rules/no-effect-wrapper-alias
  */
-import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
 
 const isEffectFnCall = (node: unknown): boolean => {
   if (node == null || typeof node !== "object") return false

package/src/rules/no-extends-native-error.ts

@@ -5,8 +5,7 @@
  *
  * Source: language-service/extendsNativeError
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 const nativeErrors = new Set([

package/src/rules/no-flatmap-ladder.ts

@@ -6,10 +6,8 @@
  * Source: biome-effect-linting-rules/no-flatmap-ladder
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Ref from "effect/Ref"
 
 const isEffectFlatMap = (node: ESTree.CallExpression): boolean =>
   AST.isCallOf(node, "Effect", "flatMap")

package/src/rules/no-fromnullable-coalesce.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-fromnullable-nullish-coalesce
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { AST, Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noFromNullableCoalesce = Rule.define({

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

@@ -0,0 +1,104 @@
+/**
+ * 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

@@ -0,0 +1,83 @@
+/**
+ * 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

@@ -0,0 +1,178 @@
+/**
+ * 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-iife-wrapper.ts

@@ -5,8 +5,7 @@
  *
  * Source: biome-effect-linting-rules/no-iife-wrapper
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noIifeWrapper = Rule.define({

package/src/rules/{no-inline-runtime-provide.ts → no-inline-provide.ts}

@@ -6,15 +6,14 @@
  * Source: biome-effect-linting-rules/no-inline-runtime-provide
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+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 noInlineRuntimeProvide = Rule.define({
-  name: "no-inline-runtime-provide",
+export const noInlineProvide = Rule.define({
+  name: "no-inline-provide",
   meta: Rule.meta({
     type: "suggestion",
     description:

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

@@ -8,8 +8,7 @@
  * Note: Without type information, we detect common Effect Schema class names
  * used in `instanceof` checks. This is a best-effort heuristic.
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noInstanceofSchema = Rule.define({
@@ -32,7 +31,7 @@ export const noInstanceofSchema = Rule.define({
             Diagnostic.make({
               node,
               message:
-                "Avoid instanceof. Use Schema.is(SchemaType) for Schema types, or _tag checks for tagged types.",
+                "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.",
             }),
           )
         }

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

@@ -5,8 +5,7 @@
  *
  * Source: biome-effect-linting-rules/no-manual-effect-channels
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
 
 export const noManualEffectChannels = Rule.define({

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

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-match-effect-branch
  */
 import type { ESTree } from "@oxlint/plugins"
-import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
+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"])