oxlint-plugin-effect 0.0.0 → 0.2.0

package/tests/context-rules.test.ts

@@ -1,105 +1,101 @@
 import { describe, test, expect } from "bun:test"
 import { Testing } from "../src/vendor/effect-oxlint/index.js"
 import {
-  noPlatformGlobals,
-  noThrowInEffectGen,
-  noTryCatchInEffectGen,
-  noConsoleInEffect,
-  noFetchInEffect,
-  noDateInEffect,
-  noRandomInEffect,
-  noTimersInEffect,
-  noJsonInEffect,
-  noProcessEnvInEffect,
+  noGlobals,
+  noThrowStatement,
+  noTryCatch,
+  noNewPromise,
+  noNewError,
+  noReturnNullish,
+  noRunInEffectGen,
 } from "../src/rules/index.js"
 
 // Helper: simulate entering and exiting Effect.gen context
 const effectGenNode = Testing.callOfMember("Effect", "gen", [])
 
-/**
- * For context-aware rules, we need to:
- * 1. Enter Effect.gen (CallExpression event)
- * 2. Fire the target event (ThrowStatement, MemberExpression, etc.)
- * 3. Exit Effect.gen (CallExpression:exit event)
- *
- * Using runRuleMulti to simulate the sequence.
- */
+// --- Global Effect-enforcing rules (fire everywhere) ---
 
-describe("noThrowInEffectGen", () => {
-  test("reports throw inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noThrowInEffectGen, [
-      ["CallExpression", effectGenNode],
-      ["ThrowStatement", Testing.throwStmt()],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noThrowStatement", () => {
+  test("reports throw", () => {
+    const result = Testing.runRule(noThrowStatement, "ThrowStatement", Testing.throwStmt())
     expect(result.length).toBe(1)
   })
+})
 
-  test("ignores throw outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noThrowInEffectGen, [
-      ["ThrowStatement", Testing.throwStmt()],
-    ])
-    Testing.expectNoDiagnostics(result)
+describe("noTryCatch", () => {
+  test("reports try/catch", () => {
+    const result = Testing.runRule(noTryCatch, "TryStatement", Testing.tryStmt())
+    expect(result.length).toBe(1)
   })
 })
 
-describe("noTryCatchInEffectGen", () => {
-  test("reports try/catch inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
-      ["CallExpression", effectGenNode],
-      ["TryStatement", Testing.tryStmt()],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noNewPromise", () => {
+  test("reports new Promise()", () => {
+    const result = Testing.runRule(noNewPromise, "NewExpression", Testing.newExpr("Promise"))
     expect(result.length).toBe(1)
   })
+})
 
-  test("ignores try/catch outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTryCatchInEffectGen, [
-      ["TryStatement", Testing.tryStmt()],
-    ])
+describe("noNewError", () => {
+  test("reports new Error()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("Error"))
+    expect(result.length).toBe(1)
+  })
+
+  test("reports new TypeError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("TypeError"))
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores new MyError()", () => {
+    const result = Testing.runRule(noNewError, "NewExpression", Testing.newExpr("MyError"))
     Testing.expectNoDiagnostics(result)
   })
 })
 
-describe("noConsoleInEffect", () => {
-  test("reports console.log inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noConsoleInEffect, [
-      ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("console", "log")],
-      ["CallExpression:exit", effectGenNode],
-    ])
+describe("noReturnNullish", () => {
+  test("reports return null", () => {
+    const node = {
+      type: "ReturnStatement",
+      argument: { type: "Literal", value: null },
+    } as never
+    const result = Testing.runRule(noReturnNullish, "ReturnStatement", node)
     expect(result.length).toBe(1)
   })
 
-  test("ignores console.log outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noConsoleInEffect, [
-      ["MemberExpression", Testing.memberExpr("console", "log")],
-    ])
-    Testing.expectNoDiagnostics(result)
+  test("reports return undefined", () => {
+    const node = {
+      type: "ReturnStatement",
+      argument: { type: "Identifier", name: "undefined" },
+    } as never
+    const result = Testing.runRule(noReturnNullish, "ReturnStatement", node)
+    expect(result.length).toBe(1)
   })
 })
 
-describe("noFetchInEffect", () => {
-  test("reports fetch() inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noFetchInEffect, [
+// --- Effect-context rules (inside Effect.gen/fn only) ---
+
+describe("noGlobals", () => {
+  test("reports console.log inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
-      ["CallExpression", Testing.callExpr("fetch")],
+      ["MemberExpression", Testing.memberExpr("console", "log")],
       ["CallExpression:exit", effectGenNode],
     ])
     expect(result.length).toBe(1)
   })
 
-  test("ignores fetch() outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noFetchInEffect, [
+  test("reports fetch() inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
+      ["CallExpression", effectGenNode],
       ["CallExpression", Testing.callExpr("fetch")],
+      ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectNoDiagnostics(result)
+    expect(result.length).toBe(1)
   })
-})
 
-describe("noDateInEffect", () => {
   test("reports Date.now inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Date", "now")],
       ["CallExpression:exit", effectGenNode],
@@ -108,7 +104,7 @@ describe("noDateInEffect", () => {
   })
 
   test("reports new Date() inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["NewExpression", Testing.newExpr("Date")],
       ["CallExpression:exit", effectGenNode],
@@ -116,17 +112,8 @@ describe("noDateInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores Date.now outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noDateInEffect, [
-      ["MemberExpression", Testing.memberExpr("Date", "now")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noRandomInEffect", () => {
   test("reports Math.random inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noRandomInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Math", "random")],
       ["CallExpression:exit", effectGenNode],
@@ -134,17 +121,8 @@ describe("noRandomInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores Math.random outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noRandomInEffect, [
-      ["MemberExpression", Testing.memberExpr("Math", "random")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noTimersInEffect", () => {
   test("reports setTimeout inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTimersInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["CallExpression", Testing.callExpr("setTimeout")],
       ["CallExpression:exit", effectGenNode],
@@ -152,17 +130,8 @@ describe("noTimersInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores setTimeout outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noTimersInEffect, [
-      ["CallExpression", Testing.callExpr("setTimeout")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noJsonInEffect", () => {
   test("reports JSON.parse inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noJsonInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("JSON", "parse")],
       ["CallExpression:exit", effectGenNode],
@@ -170,17 +139,8 @@ describe("noJsonInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores JSON.parse outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noJsonInEffect, [
-      ["MemberExpression", Testing.memberExpr("JSON", "parse")],
-    ])
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
-describe("noProcessEnvInEffect", () => {
   test("reports process.env inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("process", "env")],
       ["CallExpression:exit", effectGenNode],
@@ -188,17 +148,19 @@ describe("noProcessEnvInEffect", () => {
     expect(result.length).toBe(1)
   })
 
-  test("ignores process.env outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noProcessEnvInEffect, [
-      ["MemberExpression", Testing.memberExpr("process", "env")],
+  test("reports process.exit with hint", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
+      ["CallExpression", effectGenNode],
+      ["MemberExpression", Testing.memberExpr("process", "exit")],
+      ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectNoDiagnostics(result)
+    Testing.expectDiagnostics(result, [{
+      message: "Avoid process.exit inside Effect context. Use Effect.fail or Effect.die.",
+    }])
   })
-})
 
-describe("noPlatformGlobals", () => {
   test("reports Bun.file with FileSystem hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
       ["MemberExpression", Testing.memberExpr("Bun", "file")],
       ["CallExpression:exit", effectGenNode],
@@ -208,72 +170,92 @@ describe("noPlatformGlobals", () => {
     }])
   })
 
-  test("reports Bun.serve with HttpServer hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("reports Deno.readFile with FileSystem hint", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Bun", "serve")],
+      ["MemberExpression", Testing.memberExpr("Deno", "readFile")],
       ["CallExpression:exit", effectGenNode],
     ])
     Testing.expectDiagnostics(result, [{
-      message: "Avoid Bun.serve inside Effect context. Use HttpServer from 'effect/unstable/http'.",
+      message: "Avoid Deno.readFile inside Effect context. Use FileSystem from 'effect'.",
     }])
   })
 
-  test("reports process.exit with Effect.fail hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("ignores console.log outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
+      ["MemberExpression", Testing.memberExpr("console", "log")],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores Effect.succeed inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noGlobals, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("process", "exit")],
+      ["MemberExpression", Testing.memberExpr("Effect", "succeed")],
       ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid process.exit inside Effect context. Use Effect.fail or Effect.die.",
-    }])
+    Testing.expectNoDiagnostics(result)
   })
+})
 
-  test("reports process.cwd with Path hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+describe("noRunInEffectGen", () => {
+  test("reports Effect.runPromise inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("process", "cwd")],
+      ["CallExpression", Testing.callOfMember("Effect", "runPromise", [Testing.id("x")])],
       ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid process.cwd inside Effect context. Use Path from 'effect'.",
-    }])
+    expect(result.length).toBe(1)
   })
 
-  test("reports Deno.readFile with FileSystem hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("reports Effect.runFork inside Effect.fn", () => {
+    const effectFnNode = Testing.callOfMember("Effect", "fn", [])
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectFnNode],
+      ["CallExpression", Testing.callOfMember("Effect", "runFork", [Testing.id("x")])],
+      ["CallExpression:exit", effectFnNode],
+    ])
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Runtime.runFork inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Deno", "readFile")],
+      ["CallExpression", Testing.callOfMember("Runtime", "runFork", [Testing.id("x")])],
       ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid Deno.readFile inside Effect context. Use FileSystem from 'effect'.",
-    }])
+    expect(result.length).toBe(1)
   })
 
-  test("reports unknown property with generic hint", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("ignores Effect.runForkWith inside Effect.gen (legit v4 callback boundary)", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Bun", "someNewApi")],
+      ["CallExpression", Testing.callOfMember("Effect", "runForkWith", [Testing.id("services")])],
       ["CallExpression:exit", effectGenNode],
     ])
-    Testing.expectDiagnostics(result, [{
-      message: "Avoid Bun.someNewApi inside Effect context. Wrap in a service for testability.",
-    }])
+    Testing.expectNoDiagnostics(result)
   })
 
-  test("ignores Bun.file outside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
-      ["MemberExpression", Testing.memberExpr("Bun", "file")],
+  test("ignores managedRuntime.runFork on identifier callee", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", effectGenNode],
+      ["CallExpression", Testing.callOfMember("managedRuntime", "runFork", [Testing.id("x")])],
+      ["CallExpression:exit", effectGenNode],
     ])
     Testing.expectNoDiagnostics(result)
   })
 
-  test("ignores non-platform globals inside Effect.gen", () => {
-    const result = Testing.runRuleMulti(noPlatformGlobals, [
+  test("ignores Effect.runPromise outside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
+      ["CallExpression", Testing.callOfMember("Effect", "runPromise", [Testing.id("x")])],
+    ])
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("ignores yield* child effect inside Effect.gen", () => {
+    const result = Testing.runRuleMulti(noRunInEffectGen, [
       ["CallExpression", effectGenNode],
-      ["MemberExpression", Testing.memberExpr("Effect", "succeed")],
+      ["CallExpression", Testing.callOfMember("Effect", "succeed", [Testing.id("x")])],
       ["CallExpression:exit", effectGenNode],
     ])
     Testing.expectNoDiagnostics(result)

package/tests/pattern-rules.test.ts

@@ -1,43 +1,20 @@
 import { describe, test, expect } from "bun:test"
 import { Testing } from "../src/vendor/effect-oxlint/index.js"
 import {
-  noReturnNull,
   noUnnecessaryPipe,
   noEffectSucceedVoid,
   noEffectMapVoid,
   noEffectFnGenerator,
   noExtendsNativeError,
-  noAsyncFunction,
   noIifeWrapper,
   noEffectSucceedString,
   noFromNullableCoalesce,
   noInstanceofSchema,
   noNestedPipe,
   noNestedEffectCall,
-  noFlatmapLadder,
-  noEffectOrElseLadder,
+  noPositionalLogError,
 } from "../src/rules/index.js"
 
-describe("noReturnNull", () => {
-  test("reports return null", () => {
-    const node = {
-      type: "ReturnStatement",
-      argument: { type: "Literal", value: null },
-    } as never
-    const result = Testing.runRule(noReturnNull, "ReturnStatement", node)
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores return 42", () => {
-    const node = {
-      type: "ReturnStatement",
-      argument: { type: "Literal", value: 42 },
-    } as never
-    const result = Testing.runRule(noReturnNull, "ReturnStatement", node)
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
 describe("noUnnecessaryPipe", () => {
   test("reports pipe(x) with single arg", () => {
     const node = Testing.callExpr("pipe", [Testing.id("myEffect")])
@@ -126,32 +103,6 @@ describe("noExtendsNativeError", () => {
   })
 })
 
-describe("noAsyncFunction", () => {
-  test("reports async function", () => {
-    const node = {
-      type: "FunctionDeclaration",
-      async: true,
-      id: Testing.id("fetchData"),
-      params: [],
-      body: Testing.blockStmt([]),
-    } as never
-    const result = Testing.runRule(noAsyncFunction, "FunctionDeclaration", node)
-    expect(result.length).toBe(1)
-  })
-
-  test("ignores non-async function", () => {
-    const node = {
-      type: "FunctionDeclaration",
-      async: false,
-      id: Testing.id("fetchData"),
-      params: [],
-      body: Testing.blockStmt([]),
-    } as never
-    const result = Testing.runRule(noAsyncFunction, "FunctionDeclaration", node)
-    Testing.expectNoDiagnostics(result)
-  })
-})
-
 describe("noIifeWrapper", () => {
   test("reports (() => expr)()", () => {
     const node = {
@@ -256,3 +207,41 @@ describe("noNestedEffectCall", () => {
     Testing.expectNoDiagnostics(result)
   })
 })
+
+describe("noPositionalLogError", () => {
+  test("reports Effect.logWarning with two args", () => {
+    const node = Testing.callOfMember("Effect", "logWarning", [
+      Testing.strLiteral("something failed"),
+      Testing.id("error"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    expect(result.length).toBe(1)
+  })
+
+  test("reports Effect.logError with two args", () => {
+    const node = Testing.callOfMember("Effect", "logError", [
+      Testing.strLiteral("fatal"),
+      Testing.id("err"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    expect(result.length).toBe(1)
+  })
+
+  test("ignores Effect.log with single arg", () => {
+    const node = Testing.callOfMember("Effect", "log", [
+      Testing.strLiteral("hello"),
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    Testing.expectNoDiagnostics(result)
+  })
+
+  test("allows Cause as second arg", () => {
+    const causeArg = Testing.callOfMember("Cause", "fail", [Testing.id("error")])
+    const node = Testing.callOfMember("Effect", "logWarning", [
+      Testing.strLiteral("something failed"),
+      causeArg,
+    ])
+    const result = Testing.runRule(noPositionalLogError, "CallExpression", node)
+    Testing.expectNoDiagnostics(result)
+  })
+})

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

@@ -1,46 +0,0 @@
-/**
- * Ban `console.*` calls inside Effect.gen/fn context.
- *
- * Use Effect Logger service instead.
- *
- * Source: language-service/globalConsoleInEffect
- */
-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 * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-const consoleMethods = ["log", "warn", "error", "info", "debug", "trace"]
-
-export const noConsoleInEffect = Rule.define({
-  name: "no-console-in-effect",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid console.* inside Effect.gen/fn. Use Effect Logger service.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(tracker, {
-      MemberExpression: (node) =>
-        Effect.flatMap(Ref.get(depth), (d) => {
-          if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "console", consoleMethods))) {
-            return ctx.report(
-              Diagnostic.make({
-                node,
-                message:
-                  "Avoid console.* inside Effect context. Use Effect Logger service.",
-              }),
-            )
-          }
-          return Effect.void
-        }),
-    })
-  },
-})

package/src/rules/no-date-in-effect.ts

@@ -1,61 +0,0 @@
-/**
- * Ban `Date.now()` and `new Date()` inside Effect.gen/fn context.
- *
- * Use Clock service instead.
- *
- * Source: language-service/globalDateInEffect
- */
-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 * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
-
-import { makeEffectContextTracker } from "./_effect-context.js"
-
-export const noDateInEffect = Rule.define({
-  name: "no-date-in-effect",
-  meta: Rule.meta({
-    type: "suggestion",
-    description:
-      "Avoid Date.now() and new Date() inside Effect.gen/fn. Use Clock service.",
-  }),
-  create: function* () {
-    const ctx = yield* RuleContext
-    const [depth, tracker] = yield* makeEffectContextTracker
-
-    return Visitor.merge(
-      tracker,
-      {
-        MemberExpression: (node) =>
-          Effect.flatMap(Ref.get(depth), (d) => {
-            if (d > 0 && Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "Date", "now"))) {
-              return ctx.report(
-                Diagnostic.make({ node, message: "Avoid Date.now() inside Effect context. Use Clock service." }),
-              )
-            }
-            return Effect.void
-          }),
-        NewExpression: (node) =>
-          Effect.flatMap(Ref.get(depth), (d) => {
-            if (
-              d > 0 &&
-              "callee" in node &&
-              node.callee != null &&
-              typeof node.callee === "object" &&
-              "type" in node.callee &&
-              node.callee.type === "Identifier" &&
-              "name" in node.callee &&
-              node.callee.name === "Date"
-            ) {
-              return ctx.report(
-                Diagnostic.make({ node, message: "Avoid new Date() inside Effect context. Use Clock service." }),
-              )
-            }
-            return Effect.void
-          }),
-      },
-    )
-  },
-})

package/src/rules/no-dynamic-import.ts

@@ -1,13 +0,0 @@
-/**
- * Ban dynamic `import()` expressions.
- *
- * Use static module imports.
- *
- * Source: biome-effect-linting-rules/prevent-dynamic-imports
- */
-import { Rule } from "../vendor/effect-oxlint/index.js"
-
-export const noDynamicImport = Rule.banStatement("ImportExpression", {
-  message: "Avoid dynamic import(). Use static module imports.",
-  meta: { type: "problem" },
-})