Rules

Call an Effect.callback continuation at most once on a straight-line path.

Prevent direct mutation of arrays shared with Chunk.fromArrayUnsafe.

Avoid synchronous runners for Effect constructors that are proven to suspend.

Keep escaping exceptions out of confirmed Effect generator bodies.

Detects 'any' or 'unknown' types in Effect error or requirements channels

Ensures Self type parameter matches the class name in Context/Service/Tag/Schema classes

Warns when multiple versions of an Effect-related package are detected in the program

Mirrors noImplicitAny for unannotated Effect.fn, Effect.fnUntraced, and Effect.fnUntracedEager callback parameters when no outer contextual function type exists. Requires TS's noImplicitAny: true

Detects Effect values that are neither yielded nor assigned

Detects Effects returned from non-Effect-aware Vitest callbacks

Detects Effect values with unhandled context requirements

Detects Effect values with unhandled error types

Detects Layer values with unhandled context requirements

Suggests using return yield* for Effects that never succeed

Detects bare yield (without *) inside Effect generator scopes

Warns when importing @effect/match in projects targeting Effect v4, where Match is included directly in the effect package

Warns when importing @effect/schema in projects targeting Effect v4, where Schema is included directly in the effect package

Detects usage of APIs that have been removed or renamed in Effect v4

Prevents overriding constructors in Schema classes which breaks decoding behavior

Detects Promise types in Effect success channels where they are not awaited

Reports statically known non-finite numbers passed to Schema literal constructors

Disallows instance members in classes extending Schema.Opaque

Detects unsafe type assertions that narrow Effect, Stream, or Layer error or requirements channels

Reuse a zero-argument Layer factory result within one composition graph unless the duplicate is explicitly fresh.

Fork provably long-lived work into the Layer scope instead of blocking acquisition.

Create ManagedRuntime only at a non-Effect host boundary.

Use Effect SQL transaction ownership instead of sending transaction-control statements manually.

Keep direct HTTP work outside Effect SQL transaction effects.

Require finite concurrency for Effect operations over collections that can grow.

Forward Effect's AbortSignal when adapting a directly cancellable fetch promise.

Prevent Redacted.value from exposing secrets directly inside diagnostic and telemetry sinks.

Redact statically named secret configuration values at construction.

Keeps analyzer suppression directives visible for explicit review.

Reuse closed Effect v4 schemas and parser adapters outside repeated function execution.

Use Effect service test layers instead of module mocks or method spies.

Use explicit sequencing instead of a serial Effect.all whose result is discarded.

Use Effect.catchTag or Effect.catchTags for tagged failures.

Use Effect.fn for a named generator operation.

Use Match.tagsExhaustive for a complete tagged-union transformation.

Use Predicate.isTagged for combined tagged-value narrowing.

Require a stable operation name for Effect.fn.

Warns when using error handling on Effects that never fail

Effect.fn or Effect.fnUntraced is called as an IIFE; use Effect.gen instead

Warns when using the deprecated adapter parameter in Effect.gen

Warns when an Effect is used inside an Effect failure channel

Detects nested Effects in void success channels that may cause unexecuted effects

Warns when catch callbacks return global Error type instead of typed errors

Warns when the global Error type is used in an Effect failure channel

Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires

Suggests avoiding exported zero-argument functions and service members that lazily return Effect or Stream values

Warns when Effect.sync lazily returns a Promise instead of using an async Effect constructor

Detects implementation services leaked in service methods

Warns against chaining Effect.provide calls which can cause service lifecycle issues

Suggests replacing Effect.runSync of a pure effect constructor with the synchronous *Unsafe variant exported by the same module

Warns when returning an Effect in a generator causes nested Effect<Effect<...>>

Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts

Suggests using Effect-based Schema methods instead of sync methods inside Effect generators

Discourages try/catch in Effect generators in favor of Effect error handling

Warns when catch callbacks return unknown instead of typed errors

Keep unqualified Effect.fn span names consistent with their assigned function names.

Use Effect's JSON response constructor instead of stringifying into a text response.

Pass structured values directly to Effect logging instead of serializing them first.

Warns when manually constructing AbortController inside Effect generators instead of using Effect.abortSignal

Warns when using crypto.randomUUID() outside Effect generators instead of the Effect Crypto module

Warns when using crypto.randomUUID() inside Effect generators instead of the Effect Crypto module

Warns when a class directly extends the native Error class

Warns when using console methods inside Effect generators instead of Effect.log/Logger

Warns when using Date.now() or new Date() inside Effect generators instead of Clock/DateTime

Warns when using the global fetch function inside Effect generators instead of the Effect HTTP client

Warns when using Math.random() outside Effect generators instead of the Random service

Warns when using Math.random() inside Effect generators instead of the Random service

Warns when using setTimeout/setInterval inside Effect generators instead of Effect.sleep/Schedule

Suggests using Schema.is instead of instanceof for Effect Schema types

Warns when constructing promises with new Promise instead of using Effect APIs

Warns when importing Node.js built-in modules that have Effect-native counterparts

Warns when reading process.env outside Effect generators instead of using Effect Config

Warns when reading process.env inside Effect generators instead of using Effect Config

Suggests Effect.acquireDisposable when Effect.acquireRelease only invokes the acquired resource's disposal protocol

Suggests using Effect.forEach instead of Effect.all over an effectful Array#map

Suggests Effect.catchTag or Effect.catchTags for catch-all handlers that re-fail unmatched tagged errors

Suggests using Effect.mapError instead of Effect.catch + Effect.fail

Suggests Effect.firstSuccessOf for consecutive error-independent Effect.catch fallbacks when the error type is preserved

Suggests Effect.catchIf, Effect.catchCauseIf, or Effect.catchTag for conditional catch handlers that re-fail their untouched input

Suggests using Effect.orDie instead of Effect.catch or Effect.catchAll with an identity-forwarding Effect.die handler

Suggests Effect.catchReason or Effect.catchReasons for handlers that re-fail unmatched reason._tag branches

Suggests using Effect.ignore or Effect.ignoreCause instead of Effect.catch/catchCause returning Effect.void

Suggests using Effect.orElseSucceed instead of Effect.catch + Effect.succeed

Suggests using Effect.gen or Effect.fn instead of the Effect.Do notation helpers

Suggests using Effect.fn for functions that return an Effect

Suggests using Effect.flatMap instead of Effect.map followed by Effect.flatten in piping flows

Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})

Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)

Suggests Effect.filterOrFail or Effect.filterOrElse when Effect.flatMap conditionally passes its input through with Effect.succeed

Suggests using Effect.map instead of Effect.flatMap when the callback only wraps its result with Effect.succeed

Suggests using Effect.asSome instead of Effect.map when the mapper only wraps the success value with Option.some

Suggests Effect.mapBoth when Effect.matchEffect only transforms the failure and success channels

Suggests Effect.match or Effect.matchCause when both Effect.matchEffect handlers only return Effect.succeed

Suggests using .pipe() for nested function calls

Suggests collapsing consecutive Effect.catchTag transformations into a single Effect.catchTags call when semantics stay equivalent

Warns when yielding a nested bare Effect.gen inside an existing Effect generator context

Suggests Effect.fromOption when Option.match or an Option tag conditional only converts Some to Effect.succeed and None to Effect.fail

Disallows Schema.Schema.Type<typeof X> in favor of typeof X.Type

Suggests using Effect.succeedNone or Effect.succeedSome instead of wrapping Option.none or Option.some with Effect.succeed

Suggests typed Schema decoders when the input is assignable to the schema's Encoded type

Suggests providing inline Layer.succeed and Layer.effect services directly

Suggests Effect.timeoutOrElse when Effect.raceFirst has exactly one sleep- or delay-based timer arm

Suggests hoisting a repeated trailing Effect.mapError from every yield in an Effect generator

Suggests hoisting a repeated trailing Effect.orDie from every yield in an Effect generator

Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest

Suggests using Effect.runPromiseExit instead of passing Effect.exit to Effect.runPromise

Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field

Suggests using Effect.succeed instead of Effect.sync when the thunk returns a constant value

Suggests dedicated timeout combinators instead of catching TimeoutError immediately after Effect.timeout

Suggests removing Effect.gen when it contains only a single return statement

Suggests yielding yieldable errors directly instead of wrapping with Effect.fail

Removes pipe calls with no arguments

Simplifies chained pipe calls into a single pipe call

Suggests replacing typeof Schema.Type style annotations with the matching named type when available