effect 4.0.0-beta.29 → 4.0.0-beta.30

package/src/Effect.ts

@@ -1778,8 +1778,13 @@ export {
  *
  * **When to Use**
  *
- * Use `Effect.async` when dealing with APIs that use callback-style instead of
+ * Use `Effect.callback` when dealing with APIs that use callback-style instead of
  * `async/await` or `Promise`.
+ * * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.async`
  *
  * @example
  * ```ts
@@ -7415,7 +7420,8 @@ export const sandbox: <A, E, R>(
  * it succeeds or fails. This is useful when you only care about the side
  * effects of the effect and do not need to handle or process its outcome.
  *
- * Use the `log` option to emit the full {@link Cause} when the effect fails.
+ * Use the `log` option to emit the full {@link Cause} when the effect fails,
+ * and `message` to prepend a custom log message.
  *
  * @example
  * ```ts
@@ -7439,7 +7445,7 @@ export const sandbox: <A, E, R>(
  * const task = Effect.fail("Uh oh!")
  *
  * const program = task.pipe(Effect.ignore({ log: true }))
- * const programWarn = task.pipe(Effect.ignore({ log: "Warn" }))
+ * const programWarn = task.pipe(Effect.ignore({ log: "Warn", message: "Ignoring task failure" }))
  * ```
  *
  * **Previously Known As**
@@ -7454,13 +7460,16 @@ export const sandbox: <A, E, R>(
 export const ignore: <
   Arg extends Effect<any, any, any> | {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignore
@@ -7468,7 +7477,8 @@ export const ignore: <
 /**
  * Ignores the effect's failure cause, including defects and interruptions.
  *
- * Use the `log` option to emit the full {@link Cause} when the effect fails.
+ * Use the `log` option to emit the full {@link Cause} when the effect fails,
+ * and `message` to prepend a custom log message.
  *
  * @example
  * ```ts
@@ -7477,7 +7487,7 @@ export const ignore: <
  * const task = Effect.fail("boom")
  *
  * const program = task.pipe(Effect.ignoreCause)
- * const programLog = task.pipe(Effect.ignoreCause({ log: true }))
+ * const programLog = task.pipe(Effect.ignoreCause({ log: true, message: "Ignoring failure cause" }))
  * ```
  *
  * @since 4.0.0
@@ -7486,13 +7496,16 @@ export const ignore: <
 export const ignoreCause: <
   Arg extends Effect<any, any, any> | {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
     readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignoreCause

package/src/Option.ts

@@ -94,7 +94,7 @@ import * as Reducer from "./Reducer.ts"
 import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer, NotFunction } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
-import * as Gen from "./Utils.ts"
+import type * as Gen from "./Utils.ts"
 
 const TypeId = "~effect/data/Option"
 
@@ -4669,9 +4669,7 @@ export const gen: Gen.Gen<OptionTypeLambda> = (...args) => {
   const iterator = f()
   let state: IteratorResult<any> = iterator.next()
   while (!state.done) {
-    const current = Gen.isGenKind(state.value)
-      ? state.value.value
-      : state.value
+    const current = state.value
     if (isNone(current)) {
       return current
     }

package/src/Result.ts

@@ -83,7 +83,7 @@ import type { Predicate, Refinement } from "./Predicate.ts"
 import { isFunction } from "./Predicate.ts"
 import type { Covariant, NoInfer, NotFunction } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
-import * as Gen from "./Utils.ts"
+import type * as Gen from "./Utils.ts"
 
 const TypeId = "~effect/data/Result"
 
@@ -2540,9 +2540,7 @@ export const gen: Gen.Gen<ResultTypeLambda> = (...args) => {
   const iterator = f()
   let state: IteratorResult<any> = iterator.next()
   while (!state.done) {
-    const current = Gen.isGenKind(state.value)
-      ? state.value.value
-      : state.value
+    const current = state.value
     if (isFailure(current)) {
       return current
     }

package/src/Schema.ts

@@ -53,6 +53,7 @@ import type { Assign, Lambda, Mutable, Simplify } from "./Struct.ts"
 import * as Struct_ from "./Struct.ts"
 import * as FastCheck from "./testing/FastCheck.ts"
 import type { UnionToIntersection } from "./Types.ts"
+import type { Unify } from "./Unify.ts"
 
 const TypeId = InternalSchema.TypeId
 
@@ -3226,13 +3227,19 @@ type TaggedUnionUtils<
   ) => (value: Members[number]["Type"]) => value is Extract<Members[number]["Type"], { _tag: Keys }>
   readonly guards: { [M in Flattened[number] as M["Type"][Tag]]: (u: unknown) => u is M["Type"] }
   readonly match: {
-    <Output>(
+    <
+      Cases extends { [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any }
+    >(
       value: Members[number]["Type"],
-      cases: { [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => Output }
-    ): Output
-    <Output>(
-      cases: { [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => Output }
-    ): (value: Members[number]["Type"]) => Output
+      cases: Cases
+    ): Cases[keyof Cases] extends (value: any) => infer R ? Unify<R>
+      : never
+    <
+      Cases extends { [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any }
+    >(
+      cases: Cases
+    ): (value: Members[number]["Type"]) => Cases[keyof Cases] extends (value: any) => infer R ? Unify<R>
+      : never
   }
 }
 

package/src/ServiceMap.ts

@@ -62,7 +62,7 @@ export interface Key<in out Identifier, in out Shape> extends Pipeable, Inspecta
 export interface Service<in out Identifier, in out Shape>
   extends Key<Identifier, Shape>, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier>
 {
-  of(self: Shape): Shape
+  of(this: void, self: Shape): Shape
   serviceMap(self: Shape): ServiceMap<Identifier>
   use<A, E, R>(f: (service: Shape) => Effect<A, E, R>): Effect<A, E, R | Identifier>
   useSync<A>(f: (service: Shape) => A): Effect<A, never, Identifier>
@@ -279,7 +279,7 @@ const ServiceProto: any = {
     const fn = this.asEffect = constant(withFiber((fiber) => exitSucceed(get(fiber.services, this))))
     return fn()
   },
-  of<Service>(self: Service): Service {
+  of<Service>(this: void, self: Service): Service {
     return self
   },
   serviceMap<Identifier, Shape>(

package/src/Utils.ts

@@ -1,65 +1,102 @@
 /**
+ * Internal utilities for the Effect ecosystem's generator-based syntax and
+ * higher-kinded type machinery.
+ *
+ * ## Mental model
+ *
+ * - **SingleShotGen** — an `IterableIterator` wrapper that yields its value
+ *   exactly once. Used internally by `[Symbol.iterator]()` on Effect, Option,
+ *   Result, and other yieldable types so they work inside generator functions.
+ * - **Gen** — a type-level signature for generator-based monadic composition
+ *   (`gen` functions). Parametric over any `TypeLambda` so each module
+ *   (Effect, Option, Result, ...) can expose its own `gen` with correct types.
+ * - **Variance** — a type-level marker that encodes the variance (covariant,
+ *   contravariant, invariant) of a `TypeLambda`'s type parameters.
+ *   Used by {@link Gen} for type inference.
+ *
+ * ## Common tasks
+ *
+ * - Make a type yieldable in generators -> implement `[Symbol.iterator]()` returning a {@link SingleShotGen}
+ * - Define a generator-based API for a new TypeLambda -> type it as {@link Gen}`<MyTypeLambda>`
+ * - Encode variance for a higher-kinded type -> use {@link Variance}
+ *
+ * ## Gotchas
+ *
+ * - {@link SingleShotGen} yields its value only on the first `.next()` call.
+ *   Calling `.next()` again returns `{ done: true }`. Iterating the same
+ *   instance twice will skip the value on the second pass; call
+ *   `[Symbol.iterator]()` to get a fresh iterator.
+ * - {@link Gen} and {@link Variance} are pure type-level constructs — they
+ *   have no runtime representation.
+ *
+ * ## Quickstart
+ *
+ * **Example** (Using SingleShotGen to make a type yieldable)
+ *
+ * ```ts
+ * import { Utils } from "effect"
+ *
+ * class MyWrapper<A> {
+ *   constructor(readonly value: A) {}
+ *   [Symbol.iterator]() {
+ *     return new Utils.SingleShotGen<MyWrapper<A>, A>(this)
+ *   }
+ * }
+ *
+ * const w = new MyWrapper(42)
+ * const iter = w[Symbol.iterator]()
+ * console.log(iter.next(undefined as any))
+ * // { value: MyWrapper { value: 42 }, done: false }
+ * console.log(iter.next(42))
+ * // { value: 42, done: true }
+ * ```
+ *
+ * @see {@link SingleShotGen}
+ * @see {@link Gen}
+ * @see {@link Variance}
+ *
  * @since 2.0.0
  */
-import { identity } from "./Function.ts"
 import type { Kind, TypeLambda } from "./HKT.ts"
-import { isObject } from "./Predicate.ts"
 import type * as Types from "./Types.ts"
 
 /**
- * @since 2.0.0
- */
-const GenKindTypeId = "~effect/Utils/GenKind"
-
-/**
- * @category models
- * @since 2.0.0
- */
-export interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R, O, E> {
-  readonly value: Kind<F, R, O, E, A>
-
-  [Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A>
-}
-
-/**
- * @category predicates
- * @since 3.0.6
- */
-export const isGenKind = (u: unknown): u is GenKind<any, any, any, any, any> => isObject(u) && GenKindTypeId in u
-
-class GenKindImpl<F extends TypeLambda, R, O, E, A> implements GenKind<F, R, O, E, A> {
-  readonly value: Kind<F, R, O, E, A>
-
-  constructor(
-    value: Kind<F, R, O, E, A>
-  ) {
-    this.value = value
-  }
-
-  get _F() {
-    return identity
-  }
-
-  get _R() {
-    return (_: R) => _
-  }
-
-  get _O() {
-    return (_: never): O => _
-  }
-
-  get _E() {
-    return (_: never): E => _
-  }
-
-  readonly [GenKindTypeId]: typeof GenKindTypeId = GenKindTypeId;
-
-  [Symbol.iterator](): IterableIterator<GenKind<F, R, O, E, A>, A> {
-    return new SingleShotGen<GenKind<F, R, O, E, A>, A>(this as any)
-  }
-}
-
-/**
+ * An `IterableIterator` that yields its wrapped value exactly once.
+ *
+ * When to use:
+ *
+ * - Implement `[Symbol.iterator]()` on Effect-like types so they can be
+ *   `yield*`-ed inside generator functions (e.g. `Effect.gen`, `Option.gen`).
+ * - You almost never construct this directly — it is created internally by
+ *   yieldable types.
+ *
+ * Behavior:
+ *
+ * - The first call to `next()` returns `{ value: self, done: false }`.
+ * - Every subsequent call returns `{ value: a, done: true }` where `a` is
+ *   the argument passed to `next()`.
+ * - `[Symbol.iterator]()` returns a **new** `SingleShotGen` wrapping the same
+ *   value, so the outer type can be iterated multiple times.
+ * - Does not mutate the wrapped value.
+ *
+ * **Example** (Yielding a wrapped value in a generator)
+ *
+ * ```ts
+ * import { Utils } from "effect"
+ *
+ * const gen = new Utils.SingleShotGen<string, number>("hello")
+ *
+ * // First call yields the wrapped value
+ * console.log(gen.next(0))
+ * // { value: "hello", done: false }
+ *
+ * // Second call signals completion with the provided value
+ * console.log(gen.next(42))
+ * // { value: 42, done: true }
+ * ```
+ *
+ * @see {@link Gen} — the type-level signature that relies on `SingleShotGen`
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -96,20 +133,29 @@ export class SingleShotGen<T, A> implements IterableIterator<T, A> {
 }
 
 /**
- * @category constructors
- * @since 2.0.0
- */
-export const makeGenKind = <F extends TypeLambda, R, O, E, A>(
-  kind: Kind<F, R, O, E, A>
-): GenKind<F, R, O, E, A> => new GenKindImpl(kind)
-
-/**
- * @example
+ * Type-level marker encoding the variance of a `TypeLambda`'s type
+ * parameters.
+ *
+ * When to use:
+ *
+ * - Define variance constraints for a higher-kinded type so that
+ *   {@link Gen} can correctly infer `R`, `O`, and `E` from yielded values.
+ * - You typically don't construct values of this type — it exists purely for
+ *   type inference.
+ *
+ * Behavior:
+ *
+ * - `F` is invariant (must match exactly).
+ * - `R` is contravariant (input / environment position).
+ * - `O` and `E` are covariant (output / error position).
+ * - Pure type-level construct — no runtime representation.
+ *
+ * **Example** (Declaring variance for a TypeLambda)
+ *
  * ```ts
  * import type { Utils } from "effect"
  * import type * as Option from "effect/Option"
  *
- * // Variance defines the type parameter relationships
  * declare const variance: Utils.Variance<
  *   Option.OptionTypeLambda,
  *   never,
@@ -118,11 +164,12 @@ export const makeGenKind = <F extends TypeLambda, R, O, E, A>(
  * >
  * ```
  *
+ * @see {@link Gen} — uses `Variance` for type parameter inference
+ *
  * @category models
  * @since 2.0.0
  */
 export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
-  readonly [GenKindTypeId]: typeof GenKindTypeId
   readonly _F: Types.Invariant<F>
   readonly _R: Types.Contravariant<R>
   readonly _O: Types.Covariant<O>
@@ -130,14 +177,34 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
 }
 
 /**
- * @example
+ * Type-level signature for generator-based monadic composition over any
+ * `TypeLambda`.
+ *
+ * When to use:
+ *
+ * - Type the `gen` function of a module that supports generator syntax
+ *   (e.g. `Option.gen`, `Result.gen`, `Effect.gen`).
+ * - Accepts either `(body)` or `(self, body)` where `body` is a generator
+ *   function. The `self` overload binds `this` inside the generator.
+ *
+ * Behavior:
+ *
+ * - Pure type alias — no runtime behavior.
+ * - Infers `R`, `O`, `E` from the yielded values via {@link Variance} or
+ *   `Kind` constraints.
+ * - The generator's return type `A` becomes the output's `A` parameter.
+ *
+ * **Example** (Typing a gen function for Option)
+ *
  * ```ts
  * import type { Option, Utils } from "effect"
  *
- * // Gen enables generator-based syntax for any TypeLambda
  * declare const gen: Utils.Gen<Option.OptionTypeLambda>
  * ```
  *
+ * @see {@link Variance} — encodes the variance used for inference
+ * @see {@link SingleShotGen} — the iterator protocol that makes yielding work
+ *
  * @category models
  * @since 2.0.0
  */
@@ -168,22 +235,7 @@ export type Gen<F extends TypeLambda> = <
   A
 >
 
-/**
- * @example
- * ```ts
- * import type { Utils } from "effect"
- *
- * const value1: Utils.OptionalNumber = 42
- * const value2: Utils.OptionalNumber = null
- * const value3: Utils.OptionalNumber = undefined
- * ```
- *
- * @category models
- * @since 2.0.0
- */
-export type OptionalNumber = number | null | undefined
-
-const InternalTypeId = "~effect/Effect/internal"
+const InternalTypeId = "~effect/Utils/internal"
 
 const standard = {
   [InternalTypeId]: <A>(body: () => A) => {
@@ -203,31 +255,5 @@ const forced = {
 
 const isNotOptimizedAway = standard[InternalTypeId](() => new Error().stack)?.includes(InternalTypeId) === true
 
-/**
- * @since 3.2.2
- * @status experimental
- * @category tracing
- */
+/** @internal */
 export const internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[InternalTypeId]
-
-const genConstructor = (function*() {}).constructor
-
-/**
- * @example
- * ```ts
- * import { Utils } from "effect"
- *
- * function* generatorFn() {
- *   yield 1
- *   yield 2
- * }
- *
- * console.log(Utils.isGeneratorFunction(generatorFn)) // true
- * console.log(Utils.isGeneratorFunction(() => {})) // false
- * ```
- *
- * @category predicates
- * @since 3.11.0
- */
-export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
-  isObject(u) && u.constructor === genConstructor

package/src/index.ts

@@ -4167,6 +4167,62 @@ export * as UndefinedOr from "./UndefinedOr.ts"
 export * as Unify from "./Unify.ts"
 
 /**
+ * Internal utilities for the Effect ecosystem's generator-based syntax and
+ * higher-kinded type machinery.
+ *
+ * ## Mental model
+ *
+ * - **SingleShotGen** — an `IterableIterator` wrapper that yields its value
+ *   exactly once. Used internally by `[Symbol.iterator]()` on Effect, Option,
+ *   Result, and other yieldable types so they work inside generator functions.
+ * - **Gen** — a type-level signature for generator-based monadic composition
+ *   (`gen` functions). Parametric over any `TypeLambda` so each module
+ *   (Effect, Option, Result, ...) can expose its own `gen` with correct types.
+ * - **Variance** — a type-level marker that encodes the variance (covariant,
+ *   contravariant, invariant) of a `TypeLambda`'s type parameters.
+ *   Used by {@link Gen} for type inference.
+ *
+ * ## Common tasks
+ *
+ * - Make a type yieldable in generators -> implement `[Symbol.iterator]()` returning a {@link SingleShotGen}
+ * - Define a generator-based API for a new TypeLambda -> type it as {@link Gen}`<MyTypeLambda>`
+ * - Encode variance for a higher-kinded type -> use {@link Variance}
+ *
+ * ## Gotchas
+ *
+ * - {@link SingleShotGen} yields its value only on the first `.next()` call.
+ *   Calling `.next()` again returns `{ done: true }`. Iterating the same
+ *   instance twice will skip the value on the second pass; call
+ *   `[Symbol.iterator]()` to get a fresh iterator.
+ * - {@link Gen} and {@link Variance} are pure type-level constructs — they
+ *   have no runtime representation.
+ *
+ * ## Quickstart
+ *
+ * **Example** (Using SingleShotGen to make a type yieldable)
+ *
+ * ```ts
+ * import { Utils } from "effect"
+ *
+ * class MyWrapper<A> {
+ *   constructor(readonly value: A) {}
+ *   [Symbol.iterator]() {
+ *     return new Utils.SingleShotGen<MyWrapper<A>, A>(this)
+ *   }
+ * }
+ *
+ * const w = new MyWrapper(42)
+ * const iter = w[Symbol.iterator]()
+ * console.log(iter.next(undefined as any))
+ * // { value: MyWrapper { value: 42 }, done: false }
+ * console.log(iter.next(42))
+ * // { value: 42, done: true }
+ * ```
+ *
+ * @see {@link SingleShotGen}
+ * @see {@link Gen}
+ * @see {@link Variance}
+ *
  * @since 2.0.0
  */
 export * as Utils from "./Utils.ts"

package/src/internal/effect.ts

@@ -216,7 +216,8 @@ export const causeInterruptors = <E>(self: Cause.Cause<E>): ReadonlySet<number>
 const emptySet = new Set<number>()
 
 /** @internal */
-export const hasInterruptsOnly = <E>(self: Cause.Cause<E>): boolean => self.reasons.every(isInterruptReason)
+export const hasInterruptsOnly = <E>(self: Cause.Cause<E>): boolean =>
+  self.reasons.length > 0 && self.reasons.every(isInterruptReason)
 
 /** @internal */
 export const reasonAnnotations = <E>(
@@ -3182,13 +3183,16 @@ export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect
 export const ignore: <
   Arg extends Effect.Effect<any, any, any> | {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3197,6 +3201,7 @@ export const ignore: <
       self: Effect.Effect<A, E, R>,
       options?: {
         readonly log?: boolean | LogLevel.Severity | undefined
+        readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
@@ -3206,7 +3211,11 @@ export const ignore: <
       return matchCauseEffect(self, {
         onFailure(cause) {
           const failure = findFail(cause)
-          return Result.isFailure(failure) ? failCause(failure.failure) : logEffect(cause)
+          return Result.isFailure(failure)
+            ? failCause(failure.failure)
+            : options.message === undefined
+            ? logEffect(cause)
+            : logEffect(options.message, cause)
         },
         onSuccess: (_) => void_
       })
@@ -3217,13 +3226,16 @@ export const ignore: <
 export const ignoreCause: <
   Arg extends Effect.Effect<any, any, any> | {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
     readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3232,13 +3244,17 @@ export const ignoreCause: <
       self: Effect.Effect<A, E, R>,
       options?: {
         readonly log?: boolean | LogLevel.Severity | undefined
+        readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
         return matchCauseEffect(self, { onFailure: (_) => void_, onSuccess: (_) => void_ })
       }
       const logEffect = logWithLevel(options.log === true ? undefined : options.log)
-      return matchCauseEffect(self, { onFailure: logEffect, onSuccess: (_) => void_ })
+      return matchCauseEffect(self, {
+        onFailure: (cause) => options.message === undefined ? logEffect(cause) : logEffect(options.message, cause),
+        onSuccess: (_) => void_
+      })
     }
   )
 
@@ -6056,7 +6072,7 @@ const prettyLoggerTty = (options: {
   readonly formatDate: (date: Date) => string
 }) => {
   const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
-  const color = options.colors && processStdoutIsTTY ? withColor : withColorNoop
+  const color = options.colors ? withColor : withColorNoop
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
       const console = fiber.getRef(ConsoleRef)