oxlint-plugin-effect 0.0.0 → 0.1.0

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

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-match-void-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 isEffectVoid = (node: unknown): boolean => {

package/src/rules/no-multiple-effect-provide.ts

@@ -0,0 +1,75 @@
+/**
+ * Ban consecutive `Effect.provide()` calls — merge into one.
+ *
+ * Detects: `effect.pipe(Effect.provide(A), Effect.provide(B))`
+ * Suggests: `effect.pipe(Effect.provide(Layer.mergeAll(A, B)))`
+ *
+ * This is an AST heuristic — it catches the common patterns without
+ * needing the type checker to confirm they're actually Layer values.
+ *
+ * Source: language-service/multipleEffectProvide
+ */
+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 isEffectProvide = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Effect", "provide"))
+}
+
+const countProvides = (args: ReadonlyArray<ESTree.Node>): number => {
+  let count = 0
+  for (const arg of args) {
+    if (isEffectProvide(arg as ESTree.Node)) count++
+  }
+  return count
+}
+
+export const noMultipleEffectProvide = Rule.define({
+  name: "no-multiple-effect-provide",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid consecutive Effect.provide() calls. Merge into Effect.provide(Layer.mergeAll(...)).",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const call = node as ESTree.CallExpression
+        const args = call.arguments
+        if (args.length < 3) return Effect.void
+
+        // Check bare pipe() or .pipe() with multiple Effect.provide args
+        const calleeName = Option.getOrUndefined(AST.calleeName(call))
+        const callee = call.callee
+
+        const isPipe =
+          calleeName === "pipe" ||
+          (callee.type === "MemberExpression" &&
+            "property" in callee &&
+            (callee as unknown as Record<string, unknown>)["computed"] !== true &&
+            (() => {
+              const prop = (callee as unknown as Record<string, unknown>)["property"]
+              return prop != null && typeof prop === "object" && "name" in prop && prop.name === "pipe"
+            })())
+
+        if (!isPipe) return Effect.void
+
+        if (countProvides(args as ReadonlyArray<ESTree.Node>) >= 2) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Multiple Effect.provide() in pipe. Merge into Effect.provide(Layer.mergeAll(...)).",
+            }),
+          )
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-nested-effect-call.ts

@@ -6,10 +6,8 @@
  * Sources: biome-effect-linting-rules/no-nested-effect-call, no-effect-call-in-effect-arg, no-call-tower, no-effect-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 { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
 
 const isEffectCall = (node: unknown): boolean => {
   if (node == null || typeof node !== "object") return false

package/src/rules/no-nested-effect-gen.ts

@@ -6,8 +6,7 @@
  * Sources: biome-effect-linting-rules/no-nested-effect-gen, language-service/nestedEffectGenYield
  */
 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"
 

package/src/rules/no-nested-pipe.ts

@@ -6,11 +6,8 @@
  * Sources: biome-effect-linting-rules/no-pipe-ladder, language-service/unnecessaryPipeChain
  */
 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 { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import { pipe } from "effect/Function"
 
 const isPipeCall = (node: ESTree.Node): boolean => {
   if (node.type === "CallExpression" && "callee" in node) {

package/src/rules/no-new-error.ts

@@ -1,17 +1,53 @@
 /**
- * Ban `new Error(...)`.
+ * Ban `new Error(...)` and native error constructors. Context-aware messaging.
  *
- * Use Schema.TaggedErrorClass or Data.TaggedError instead.
+ * Inside Effect.gen/fn: "Use yield* new MyError() (yieldable TaggedErrorClass)"
+ * Outside: "Define class MyError extends Schema.TaggedErrorClass..."
  *
  * Source: language-service/globalErrorInEffectFailure, extendsNativeError
  */
-import { Rule } from "../vendor/effect-oxlint/index.js"
+import type { ESTree } from "@oxlint/plugins"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noNewError = Rule.banNewExpr(
-  ["Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError"],
-  {
-    message:
-      "Avoid native Error constructors. Use Schema.TaggedErrorClass or Data.TaggedError.",
-    meta: { type: "suggestion" },
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+const nativeErrors = new Set([
+  "Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError",
+  "URIError", "EvalError",
+])
+
+export const noNewError = Rule.define({
+  name: "no-new-error",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid native Error constructors. Use Schema.TaggedErrorClass.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      NewExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          const callee = (node as unknown as Record<string, unknown>)["callee"] as ESTree.Node
+          if (
+            callee.type === "Identifier" &&
+            "name" in callee &&
+            nativeErrors.has(callee.name as string)
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: d > 0
+                  ? "Avoid native Error inside Effect.gen/fn. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { ... }) {} — then yield* new MyError()."
+                  : "Avoid native Error constructors. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { message: Schema.String }) {}",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
   },
-)
+})

package/src/rules/no-new-promise.ts

@@ -1,14 +1,50 @@
 /**
- * Ban `new Promise(...)`.
+ * Ban `new Promise()`. Context-aware messaging.
  *
- * Use Effect.async, Effect.tryPromise, or Effect.promise instead.
+ * Inside Effect.gen/fn: "Use Effect.tryPromise or Effect.async"
+ * Outside: "Use Effect.tryPromise or wrap with Effect.fn"
  *
  * Source: language-service/newPromise
  */
-import { Rule } from "../vendor/effect-oxlint/index.js"
+import { Diagnostic, Rule, Visitor, RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
 
-export const noNewPromise = Rule.banNewExpr("Promise", {
-  message:
-    "Avoid new Promise(). Use Effect.async, Effect.tryPromise, or Effect.promise.",
-  meta: { type: "suggestion" },
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+export const noNewPromise = Rule.define({
+  name: "no-new-promise",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid new Promise(). Use Effect.async or Effect.tryPromise.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      NewExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          const callee = (node as unknown as Record<string, unknown>)["callee"]
+          if (
+            callee != null &&
+            typeof callee === "object" &&
+            "type" in callee &&
+            callee.type === "Identifier" &&
+            "name" in callee &&
+            callee.name === "Promise"
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: d > 0
+                  ? "Avoid new Promise() inside Effect.gen/fn. Use Effect.async for callback APIs, Effect.tryPromise for existing promises, or Effect.promise for infallible promises."
+                  : "Avoid new Promise(). Use Effect.async for callback APIs, Effect.tryPromise for existing promises — wrap this function with Effect.fn.",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
 })

package/src/rules/no-node-builtin-import.ts

@@ -5,9 +5,7 @@
  *
  * Source: language-service/nodeBuiltinImport
  */
-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"
 import * as Option from "effect/Option"
 

package/src/rules/no-option-boolean-normalization.ts

@@ -6,8 +6,7 @@
  * Source: biome-effect-linting-rules/no-option-boolean-normalization
  */
 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 noOptionBooleanNormalization = Rule.define({

package/src/rules/no-positional-log-error.ts

@@ -0,0 +1,76 @@
+/**
+ * Ban positional error/cause arguments in Effect.log* calls.
+ *
+ * `Effect.logWarning("message", error)` loses error structure.
+ * Use `Effect.logWarning("message").pipe(Effect.annotateLogs({ error }))` instead,
+ * or pass cause via `Effect.logWarning("message", Cause.fail(error))`.
+ *
+ * Source: agent session analysis — 57 occurrences across 6 projects
+ */
+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 logMethods = new Set([
+  "log",
+  "logDebug",
+  "logInfo",
+  "logWarning",
+  "logError",
+  "logFatal",
+  "logTrace",
+])
+
+export const noPositionalLogError = Rule.define({
+  name: "no-positional-log-error",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid passing errors as positional arguments to Effect.log*. Use Effect.annotateLogs instead.",
+  }),
+  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 (!logMethods.has(prop)) return Effect.void
+
+        // Effect.log* with more than 1 argument — the second arg is likely
+        // an error/cause being passed positionally
+        const args = call.arguments
+        if (args.length < 2) return Effect.void
+
+        // The first arg should be a string message. If second arg exists,
+        // it's likely an error being passed positionally.
+        const secondArg = args[1]
+        if (secondArg === undefined) return Effect.void
+
+        // Allow Cause.fail/Cause.die as second arg (that's the proper API)
+        if (secondArg.type === "CallExpression") {
+          const secondNames = Option.getOrUndefined(
+            AST.memberNames((secondArg as ESTree.CallExpression).callee as ESTree.MemberExpression),
+          )
+          if (secondNames !== undefined) {
+            const [sObj] = secondNames
+            if (sObj === "Cause") return Effect.void
+          }
+        }
+
+        return ctx.report(
+          Diagnostic.make({
+            node: secondArg,
+            message:
+              `Avoid passing errors as positional args to Effect.${prop}. Use .pipe(Effect.annotateLogs({ error: String(err) })) or pass a Cause.`,
+          }),
+        )
+      },
+    }
+  },
+})

package/src/rules/no-redundant-schema-tag-identifier.ts

@@ -0,0 +1,62 @@
+/**
+ * Ban redundant `_tag` in `Schema.TaggedStruct("Foo", { _tag: Schema.Literal("Foo") })`.
+ *
+ * `TaggedStruct` already provides `_tag` automatically.
+ *
+ * Source: language-service/redundantSchemaTagIdentifier
+ */
+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 isTagKey = (key: ESTree.Node): boolean => {
+  if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true
+  if (key.type === "Literal" && "value" in key && key.value === "_tag") return true
+  return false
+}
+
+export const noRedundantSchemaTagIdentifier = Rule.define({
+  name: "no-redundant-schema-tag-identifier",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Redundant _tag in TaggedStruct. TaggedStruct already provides _tag automatically.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const call = node as ESTree.CallExpression
+        if (Option.isNone(AST.matchCallOf(call, "Schema", "TaggedStruct"))) return Effect.void
+
+        // TaggedStruct("tag", { fields })
+        const args = call.arguments
+        if (args.length < 2) return Effect.void
+        const fieldsArg = args[1]
+        if (fieldsArg === undefined) return Effect.void
+        if (fieldsArg.type !== "ObjectExpression") return Effect.void
+
+        const props = (fieldsArg as unknown as Record<string, unknown>)["properties"]
+        if (!Array.isArray(props)) return Effect.void
+
+        for (const prop of props) {
+          const p = prop as ESTree.Node
+          if (p.type !== "Property") continue
+          const key = (p as unknown as Record<string, unknown>)["key"] as ESTree.Node
+          if (isTagKey(key)) {
+            return ctx.report(
+              Diagnostic.make({
+                node: p,
+                message:
+                  "Redundant _tag property. Schema.TaggedStruct already provides _tag automatically.",
+              }),
+            )
+          }
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-return-in-arrow.ts

@@ -6,8 +6,7 @@
  *
  * Source: biome-effect-linting-rules/no-return-in-arrow
  */
-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 noReturnInArrow = Rule.define({

package/src/rules/no-return-nullish.ts

@@ -0,0 +1,80 @@
+/**
+ * Ban `return null`, `return undefined`, `return void 0`. Context-aware messaging.
+ *
+ * Inside Effect.gen/fn: "Use Option.none() or Effect.void"
+ * Outside: "Use Option.none() — convert nullish at system boundaries with Option.fromNullable"
+ *
+ * Source: biome-effect-linting-rules/no-return-null (extended)
+ */
+import { 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 noReturnNullish = Rule.define({
+  name: "no-return-nullish",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid returning null/undefined. Use Option.none() for absence or Effect.void for void effects.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      ReturnStatement: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          if (
+            node.type !== "ReturnStatement" ||
+            !("argument" in node) ||
+            node.argument === null ||
+            node.argument === undefined
+          ) {
+            return Effect.void
+          }
+
+          const arg = node.argument as unknown as Record<string, unknown>
+
+          // return null
+          if (arg["type"] === "Literal" && arg["value"] === null) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: d > 0
+                  ? "Avoid returning null inside Effect.gen/fn. Use Option.none() for absence, or yield* Effect.fail(new MyError()) for errors."
+                  : "Avoid returning null. Use Option.none() for absence — convert nullish values at system boundaries with Option.fromNullable().",
+              }),
+            )
+          }
+
+          // return undefined
+          if (arg["type"] === "Identifier" && arg["name"] === "undefined") {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: d > 0
+                  ? "Avoid returning undefined inside Effect.gen/fn. Use Effect.void for void effects, or Option.none() for absence."
+                  : "Avoid returning undefined. Use Option.none() for absence, or restructure as an Effect returning void.",
+              }),
+            )
+          }
+
+          // return void 0
+          if (arg["type"] === "UnaryExpression" && arg["operator"] === "void") {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: d > 0
+                  ? "Avoid returning void inside Effect.gen/fn. Use Effect.void for void effects."
+                  : "Avoid returning void expression. Use Option.none() for absence.",
+              }),
+            )
+          }
+
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-schema-struct-with-tag.ts

@@ -0,0 +1,64 @@
+/**
+ * Ban `Schema.Struct({ _tag: Schema.Literal("Foo"), ... })`.
+ * Use `Schema.TaggedStruct("Foo", { ... })` instead.
+ *
+ * Source: language-service/schemaStructWithTag
+ */
+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 isTagKey = (key: ESTree.Node): boolean => {
+  if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true
+  if (key.type === "Literal" && "value" in key && key.value === "_tag") return true
+  return false
+}
+
+export const noSchemaStructWithTag = Rule.define({
+  name: "no-schema-struct-with-tag",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      'Use Schema.TaggedStruct("Tag", { ... }) instead of Schema.Struct({ _tag: Schema.Literal("Tag"), ... }).',
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const call = node as ESTree.CallExpression
+        if (Option.isNone(AST.matchCallOf(call, "Schema", "Struct"))) return Effect.void
+
+        const args = call.arguments
+        if (args.length !== 1) return Effect.void
+        const arg = args[0]
+        if (arg === undefined) return Effect.void
+        if (arg.type !== "ObjectExpression") return Effect.void
+
+        const props = (arg as unknown as Record<string, unknown>)["properties"]
+        if (!Array.isArray(props)) return Effect.void
+
+        for (const prop of props) {
+          const p = prop as ESTree.Node
+          if (p.type !== "Property") continue
+          const key = (p as unknown as Record<string, unknown>)["key"] as ESTree.Node
+          if (!isTagKey(key)) continue
+
+          // Check value is Schema.Literal(...)
+          const value = (p as unknown as Record<string, unknown>)["value"] as ESTree.Node
+          if (value.type === "CallExpression" && Option.isSome(AST.matchCallOf(value as ESTree.CallExpression, "Schema", "Literal"))) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  'Use Schema.TaggedStruct("Tag", { ... }) instead of Schema.Struct({ _tag: Schema.Literal(...), ... }).',
+              }),
+            )
+          }
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-schema-union-of-literals.ts

@@ -0,0 +1,48 @@
+/**
+ * Ban `Schema.Union(Schema.Literal("a"), Schema.Literal("b"))`.
+ * Use `Schema.Literal("a", "b")` instead.
+ *
+ * Source: language-service/schemaUnionOfLiterals
+ */
+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 isSchemaLiteral = (node: ESTree.Node): boolean => {
+  if (node.type !== "CallExpression") return false
+  return Option.isSome(AST.matchCallOf(node as ESTree.CallExpression, "Schema", "Literal"))
+}
+
+export const noSchemaUnionOfLiterals = Rule.define({
+  name: "no-schema-union-of-literals",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b')).",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const call = node as ESTree.CallExpression
+        if (Option.isNone(AST.matchCallOf(call, "Schema", "Union"))) return Effect.void
+
+        const args = call.arguments
+        if (args.length < 2) return Effect.void
+
+        // Check if all arguments are Schema.Literal calls
+        const allLiterals = args.every((arg) => isSchemaLiteral(arg as ESTree.Node))
+        if (!allLiterals) return Effect.void
+
+        return ctx.report(
+          Diagnostic.make({
+            node,
+            message:
+              "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b')).",
+          }),
+        )
+      },
+    }
+  },
+})

package/src/rules/no-string-sentinel-const.ts

@@ -7,8 +7,7 @@
  *
  * Note: Very aggressive — should probably be off by default or in a strict preset only.
  */
-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 noStringSentinelConst = Rule.define({

package/src/rules/no-ternary.ts

@@ -7,9 +7,7 @@
  *
  * Note: Very opinionated — recommended for strict functional presets only.
  */
-import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
-import { RuleContext } from "../vendor/effect-oxlint/index.js"
-import * as Effect from "effect/Effect"
+import { Diagnostic, Rule, RuleContext } from "../vendor/effect-oxlint/index.js"
 
 export const noTernary = Rule.define({
   name: "no-ternary",