effect 2.4.16 → 2.4.18

package/src/Logger.ts

@@ -192,6 +192,18 @@ export const batched: {
   ): Effect<Logger<Message, void>, never, Scope | R>
 } = fiberRuntime.batchedLogger
 
+/**
+ * @since 2.0.0
+ * @category console
+ */
+export const withConsoleLog: <M, O>(self: Logger<M, O>) => Logger<M, void> = fiberRuntime.loggerWithConsoleLog
+
+/**
+ * @since 2.0.0
+ * @category console
+ */
+export const withConsoleError: <M, O>(self: Logger<M, O>) => Logger<M, void> = fiberRuntime.loggerWithConsoleError
+
 /**
  * A logger that does nothing in response to logging events.
  *

package/src/ReadonlyArray.ts

@@ -12,6 +12,7 @@ import type { LazyArg } from "./Function.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as readonlyArray from "./internal/readonlyArray.js"
+import * as EffectIterable from "./Iterable.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
 import * as Order from "./Order.js"
@@ -713,26 +714,7 @@ export const findFirst: {
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
-} = dual(
-  2,
-  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)): Option<A> => {
-    let i = 0
-    for (const a of self) {
-      const o = f(a, i)
-      if (isBoolean(o)) {
-        if (o) {
-          return O.some(a)
-        }
-      } else {
-        if (O.isSome(o)) {
-          return o
-        }
-      }
-      i++
-    }
-    return O.none()
-  }
-)
+} = EffectIterable.findFirst
 
 /**
  * Find the last element for which a predicate holds.

package/src/index.ts

@@ -330,6 +330,13 @@ export * as HashSet from "./HashSet.js"
  */
 export * as Inspectable from "./Inspectable.js"
 
+/**
+ * This module provides utility functions for working with Iterables in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as Iterable from "./Iterable.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/config.ts

@@ -582,8 +582,8 @@ export const validate = dual<
 
 /** @internal */
 export const withDefault = dual<
-  <A2>(def: A2) => <A>(self: Config.Config<A>) => Config.Config<A | A2>,
-  <A, A2>(self: Config.Config<A>, def: A2) => Config.Config<A | A2>
+  <const A2>(def: A2) => <A>(self: Config.Config<A>) => Config.Config<A | A2>,
+  <A, const A2>(self: Config.Config<A>, def: A2) => Config.Config<A | A2>
 >(2, (self, def) =>
   orElseIf(self, {
     orElse: () => succeed(def),

package/src/internal/core-effect.ts

@@ -500,13 +500,13 @@ export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect
 
 /* @internal */
 export const filterMap = dual<
-  <A, B>(
-    pf: (a: A) => Option.Option<B>
-  ) => <E, R>(elements: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<Array<B>, E, R>,
-  <A, E, R, B>(
-    elements: Iterable<Effect.Effect<A, E, R>>,
-    pf: (a: A) => Option.Option<B>
-  ) => Effect.Effect<Array<B>, E, R>
+  <Eff extends Effect.Effect<any, any, any>, B>(
+    pf: (a: Effect.Effect.Success<Eff>) => Option.Option<B>
+  ) => (elements: Iterable<Eff>) => Effect.Effect<Array<B>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>,
+  <Eff extends Effect.Effect<any, any, any>, B>(
+    elements: Iterable<Eff>,
+    pf: (a: Effect.Effect.Success<Eff>) => Option.Option<B>
+  ) => Effect.Effect<Array<B>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>
 >(2, (elements, pf) =>
   core.map(
     core.forEachSequential(elements, identity),
@@ -683,7 +683,9 @@ const findLoop = <A, E, R>(
   })
 
 /* @internal */
-export const firstSuccessOf = <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> =>
+export const firstSuccessOf = <Eff extends Effect.Effect<any, any, any>>(
+  effects: Iterable<Eff>
+): Effect.Effect<Effect.Effect.Success<Eff>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>> =>
   core.suspend(() => {
     const list = Chunk.fromIterable(effects)
     if (!Chunk.isNonEmpty(list)) {
@@ -691,7 +693,7 @@ export const firstSuccessOf = <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>
     }
     return pipe(
       Chunk.tailNonEmpty(list),
-      ReadonlyArray.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right))
+      ReadonlyArray.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
     )
   })
 

package/src/internal/effect/circular.ts

@@ -239,19 +239,31 @@ export const forkAll: {
     options?: {
       readonly discard?: false | undefined
     }
-  ): <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<Fiber.Fiber<Array<A>, E>, never, R>
+  ): <Eff extends Effect.Effect<any, any, any>>(
+    effects: Iterable<Eff>
+  ) => Effect.Effect<
+    Fiber.Fiber<Array<Effect.Effect.Success<Eff>>, Effect.Effect.Error<Eff>>,
+    never,
+    Effect.Effect.Context<Eff>
+  >
   (options: {
     readonly discard: true
-  }): <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<void, never, R>
-  <A, E, R>(
-    effects: Iterable<Effect.Effect<A, E, R>>,
+  }): <Eff extends Effect.Effect<any, any, any>>(
+    effects: Iterable<Eff>
+  ) => Effect.Effect<void, never, Effect.Effect.Context<Eff>>
+  <Eff extends Effect.Effect<any, any, any>>(
+    effects: Iterable<Eff>,
     options?: {
       readonly discard?: false | undefined
     }
-  ): Effect.Effect<Fiber.Fiber<Array<A>, E>, never, R>
-  <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>, options: {
+  ): Effect.Effect<
+    Fiber.Fiber<Array<Effect.Effect.Success<Eff>>, Effect.Effect.Error<Eff>>,
+    never,
+    Effect.Effect.Context<Eff>
+  >
+  <Eff extends Effect.Effect<any, any, any>>(effects: Iterable<Eff>, options: {
     readonly discard: true
-  }): Effect.Effect<void, never, R>
+  }): Effect.Effect<void, never, Effect.Effect.Context<Eff>>
 } = dual((args) => Predicate.isIterable(args[0]), <A, E, R>(effects: Iterable<Effect.Effect<A, E, R>>, options: {
   readonly discard: true
 }): Effect.Effect<void, never, R> =>

package/src/internal/fiberRuntime.ts

@@ -22,6 +22,7 @@ import { dual, identity, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as HashMap from "../HashMap.js"
 import * as HashSet from "../HashSet.js"
+import * as Inspectable from "../Inspectable.js"
 import type { Logger } from "../Logger.js"
 import * as LogLevel from "../LogLevel.js"
 import type * as MetricLabel from "../MetricLabel.js"
@@ -125,7 +126,9 @@ const runtimeFiberVariance = {
 
 const absurd = (_: never): never => {
   throw new Error(
-    `BUG: FiberRuntime - ${JSON.stringify(_)} - please report an issue at https://github.com/Effect-TS/effect/issues`
+    `BUG: FiberRuntime - ${
+      Inspectable.toStringUnknown(_)
+    } - please report an issue at https://github.com/Effect-TS/effect/issues`
   )
 }
 
@@ -1352,50 +1355,41 @@ export const currentMinimumLogLevel: FiberRef.FiberRef<LogLevel.LogLevel> = glob
 )
 
 /** @internal */
-export const getConsole = (refs: FiberRefs.FiberRefs) => {
-  const defaultServicesValue = FiberRefs.getOrDefault(refs, defaultServices.currentServices)
-  const cnsl = Context.get(defaultServicesValue, consoleTag)
-  return cnsl.unsafe
-}
+export const loggerWithConsoleLog = <M, O>(self: Logger<M, O>): Logger<M, void> =>
+  internalLogger.makeLogger((opts) => {
+    const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices)
+    Context.get(services, consoleTag).unsafe.log(self.log(opts))
+  })
+
+/** @internal */
+export const loggerWithConsoleError = <M, O>(self: Logger<M, O>): Logger<M, void> =>
+  internalLogger.makeLogger((opts) => {
+    const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices)
+    Context.get(services, consoleTag).unsafe.error(self.log(opts))
+  })
 
 /** @internal */
 export const defaultLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/defaultLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.stringLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.stringLogger)
 )
 
 /** @internal */
 export const jsonLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/jsonLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.jsonLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.jsonLogger)
 )
 
 /** @internal */
 export const logFmtLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/logFmtLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.logfmtLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.logfmtLogger)
 )
 
 /** @internal */
 export const structuredLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/structuredLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.structuredLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.structuredLogger)
 )
 
 /** @internal */
@@ -1419,7 +1413,7 @@ export const tracerLogger = globalValue(
         return
       }
 
-      const attributes = Object.fromEntries(HashMap.map(annotations, (value) => internalLogger.serializeUnknown(value)))
+      const attributes = Object.fromEntries(HashMap.map(annotations, Inspectable.toStringUnknown))
       attributes["effect.fiberId"] = FiberId.threadName(fiberId)
       attributes["effect.logLevel"] = logLevel.label
 
@@ -1828,13 +1822,13 @@ export const allWith = <
 ): Effect.All.Return<Arg, O> => all(arg, options)
 
 /* @internal */
-export const allSuccesses = <A, E, R>(
-  elements: Iterable<Effect.Effect<A, E, R>>,
+export const allSuccesses = <Eff extends Effect.Effect<any, any, any>>(
+  elements: Iterable<Eff>,
   options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
   }
-): Effect.Effect<Array<A>, never, R> =>
+): Effect.Effect<Array<Effect.Effect.Success<Eff>>, never, Effect.Effect.Context<Eff>> =>
   core.map(
     all(RA.fromIterable(elements).map(core.exit), options),
     RA.filterMap((exit) => core.exitIsSuccess(exit) ? Option.some(exit.effect_instruction_i0) : Option.none())
@@ -2299,14 +2293,23 @@ const forkWithScopeOverride = <A, E, R>(
 
 /* @internal */
 export const mergeAll = dual<
-  <Z, A>(zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
-    readonly concurrency?: Concurrency | undefined
-    readonly batching?: boolean | "inherit" | undefined
-  }) => <E, R>(elements: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<Z, E, R>,
-  <A, E, R, Z>(elements: Iterable<Effect.Effect<A, E, R>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
-    readonly concurrency?: Concurrency | undefined
-    readonly batching?: boolean | "inherit" | undefined
-  }) => Effect.Effect<Z, E, R>
+  <Z, Eff extends Effect.Effect<any, any, any>>(
+    zero: Z,
+    f: (z: Z, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+    }
+  ) => (elements: Iterable<Eff>) => Effect.Effect<Z, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>,
+  <Eff extends Effect.Effect<any, any, any>, Z>(
+    elements: Iterable<Eff>,
+    zero: Z,
+    f: (z: Z, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+    }
+  ) => Effect.Effect<Z, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>>
 >(
   (args) => Predicate.isFunction(args[2]),
   <A, E, R, Z>(elements: Iterable<Effect.Effect<A, E, R>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
@@ -2416,7 +2419,13 @@ export const validateAll = dual<
 )
 
 /* @internal */
-export const raceAll = <A, E, R>(all: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> => {
+export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
+  all: Iterable<Eff>
+) => Effect.Effect<Effect.Effect.Success<Eff>, Effect.Effect.Error<Eff>, Effect.Effect.Context<Eff>> = <
+  A,
+  E,
+  R
+>(all: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> => {
   const list = Chunk.fromIterable(all)
   if (!Chunk.isNonEmpty(list)) {
     return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
@@ -2525,27 +2534,27 @@ const raceAllArbiter = <E, E1, A, A1>(
 
 /* @internal */
 export const reduceEffect = dual<
-  <A, E, R>(
-    zero: Effect.Effect<A, E, R>,
-    f: (acc: NoInfer<A>, a: NoInfer<A>, i: number) => A,
+  <Z, E, R, Eff extends Effect.Effect<any, any, any>>(
+    zero: Effect.Effect<Z, E, R>,
+    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
     }
-  ) => (elements: Iterable<Effect.Effect<A, E, R>>) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    elements: Iterable<Effect.Effect<A, E, R>>,
-    zero: Effect.Effect<A, E, R>,
-    f: (acc: NoInfer<A>, a: NoInfer<A>, i: number) => A,
+  ) => (elements: Iterable<Eff>) => Effect.Effect<Z, E | Effect.Effect.Error<Eff>, R | Effect.Effect.Context<Eff>>,
+  <Eff extends Effect.Effect<any, any, any>, Z, E, R>(
+    elements: Iterable<Eff>,
+    zero: Effect.Effect<Z, E, R>,
+    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
     }
-  ) => Effect.Effect<A, E, R>
->((args) => Predicate.isIterable(args[0]), <A, E, R>(
+  ) => Effect.Effect<Z, E | Effect.Effect.Error<Eff>, R | Effect.Effect.Context<Eff>>
+>((args) => Predicate.isIterable(args[0]), <A, E, R, Z>(
   elements: Iterable<Effect.Effect<A, E, R>>,
-  zero: Effect.Effect<A, E, R>,
-  f: (acc: NoInfer<A>, a: NoInfer<A>, i: number) => A,
+  zero: Effect.Effect<Z, E, R>,
+  f: (acc: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,
   options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
@@ -2559,14 +2568,14 @@ export const reduceEffect = dual<
         pipe(
           mergeAll(
             [zero, ...elements],
-            Option.none() as Option.Option<A>,
+            Option.none<Z>(),
             (acc, elem, i) => {
               switch (acc._tag) {
                 case "None": {
-                  return Option.some(elem)
+                  return Option.some(elem as Z)
                 }
                 case "Some": {
-                  return Option.some(f(acc.value, elem, i))
+                  return Option.some(f(acc.value, elem as A, i))
                 }
               }
             },

package/src/internal/logger.ts

@@ -1,6 +1,7 @@
 import type { LazyArg } from "../Function.js"
 import { constVoid, dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
+import * as Inspectable from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as Logger from "../Logger.js"
 import type * as LogLevel from "../LogLevel.js"
@@ -167,7 +168,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
     ]
 
     let output = outputArray.join(" ")
-    const stringMessage = serializeUnknown(message)
+    const stringMessage = Inspectable.toStringUnknown(message)
 
     if (stringMessage.length > 0) {
       output = output + " message="
@@ -205,7 +206,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuoted(serializeUnknown(value), output)
+        output = appendQuoted(Inspectable.toStringUnknown(value), output)
       }
     }
 
@@ -213,14 +214,6 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
   }
 )
 
-export const serializeUnknown = (u: unknown): string => {
-  try {
-    return typeof u === "object" ? jsonStringifyCircular(u) : String(u)
-  } catch (_) {
-    return String(u)
-  }
-}
-
 /** @internal */
 const escapeDoubleQuotes = (str: string) => `"${str.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`
 
@@ -242,7 +235,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
     ]
 
     let output = outputArray.join(" ")
-    const stringMessage = serializeUnknown(message)
+    const stringMessage = Inspectable.toStringUnknown(message, 0)
 
     if (stringMessage.length > 0) {
       output = output + " message="
@@ -280,7 +273,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuotedLogfmt(serializeUnknown(value), output)
+        output = appendQuotedLogfmt(Inspectable.toStringUnknown(value, 0), output)
       }
     }
 
@@ -340,23 +333,8 @@ export const structuredMessage = (u: unknown): unknown => {
   }
 }
 
-const jsonStringifyCircular = (obj: unknown) => {
-  let cache: Array<unknown> = []
-  const retVal = JSON.stringify(
-    obj,
-    (_key, value) =>
-      typeof value === "object" && value !== null
-        ? cache.includes(value)
-          ? undefined // circular reference
-          : cache.push(value) && value
-        : value
-  )
-  ;(cache as any) = undefined
-  return retVal
-}
-
 /** @internal */
-export const jsonLogger = map(structuredLogger, jsonStringifyCircular)
+export const jsonLogger = map(structuredLogger, Inspectable.stringifyCircular)
 
 /** @internal */
 const filterKeyName = (key: string) => key.replace(/[\s="]/g, "_")

package/src/internal/runtime.ts

@@ -8,7 +8,7 @@ import * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
 import * as FiberRefs from "../FiberRefs.js"
 import { dual, pipe } from "../Function.js"
-import { format, NodeInspectSymbol } from "../Inspectable.js"
+import * as Inspectable from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
@@ -131,38 +131,22 @@ export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect:
   }
 }
 
+class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.AsyncFiberException<A, E> {
+  readonly _tag = "AsyncFiberException"
+  constructor(readonly fiber: Fiber.RuntimeFiber<A, E>) {
+    super(
+      `Fiber #${fiber.id().id} cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work`
+    )
+    this.name = this._tag
+    this.stack = this.message
+  }
+}
+
 const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<A, E> => {
   const limit = Error.stackTraceLimit
   Error.stackTraceLimit = 0
-  const error = (new Error()) as any
+  const error = new AsyncFiberExceptionImpl(fiber)
   Error.stackTraceLimit = limit
-  const message =
-    `Fiber #${fiber.id().id} cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work`
-  const _tag = "AsyncFiberException"
-  Object.defineProperties(error, {
-    _tag: {
-      value: _tag
-    },
-    fiber: {
-      value: fiber
-    },
-    message: {
-      value: message
-    },
-    name: {
-      value: _tag
-    },
-    toString: {
-      get() {
-        return () => message
-      }
-    },
-    [NodeInspectSymbol]: {
-      get() {
-        return () => message
-      }
-    }
-  })
   return error
 }
 
@@ -177,37 +161,46 @@ export const FiberFailureCauseId: Runtime.FiberFailureCauseId = Symbol.for(
   "effect/Runtime/FiberFailure/Cause"
 ) as any
 
-type Mutable<A> = {
-  -readonly [k in keyof A]: A[k]
-}
+class FiberFailureImpl extends Error implements Runtime.FiberFailure {
+  readonly [FiberFailureId]: Runtime.FiberFailureId
+  readonly [FiberFailureCauseId]: Cause.Cause<unknown>
+  constructor(cause: Cause.Cause<unknown>) {
+    super()
+
+    this[FiberFailureId] = FiberFailureId
+    this[FiberFailureCauseId] = cause
+
+    const prettyErrors = InternalCause.prettyErrors(cause)
+    if (prettyErrors.length > 0) {
+      const head = prettyErrors[0]
+      this.name = head.message.split(":")[0]
+      this.message = head.message.substring(this.name.length + 2)
+      this.stack = InternalCause.pretty(cause)
+    }
 
-/** @internal */
-export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure => {
-  const limit = Error.stackTraceLimit
-  Error.stackTraceLimit = 0
-  const error = (new Error()) as Mutable<Runtime.FiberFailure>
-  Error.stackTraceLimit = limit
-  const prettyErrors = InternalCause.prettyErrors(cause)
-  if (prettyErrors.length > 0) {
-    const head = prettyErrors[0]
-    error.name = head.message.split(":")[0]
-    error.message = head.message.substring(error.name.length + 2)
-    error.stack = InternalCause.pretty(cause)
+    this.name = `(FiberFailure) ${this.name}`
   }
-  error[FiberFailureId] = FiberFailureId
-  error[FiberFailureCauseId] = cause
-  error.toJSON = () => {
+
+  toJSON(): unknown {
     return {
       _id: "FiberFailure",
-      cause: cause.toJSON()
+      cause: this[FiberFailureCauseId].toJSON()
     }
   }
-  error.toString = () => {
-    return format(error.toJSON())
+  toString(): string {
+    return "(FiberFailure) " + InternalCause.pretty(this[FiberFailureCauseId])
   }
-  error[NodeInspectSymbol] = () => {
-    return error.toJSON()
+  [Inspectable.NodeInspectSymbol](): unknown {
+    return this.toString()
   }
+}
+
+/** @internal */
+export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  const error = new FiberFailureImpl(cause)
+  Error.stackTraceLimit = limit
   return error
 }
 

package/src/internal/schedule.ts

@@ -1951,12 +1951,12 @@ export const retryOrElse_Effect = dual<
   <A1, E, R1, A2, E2, R2>(
     policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
     orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
-  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E | E2, R | R1 | R2>,
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2, R | R1 | R2>,
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
     orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
-  ) => Effect.Effect<A | A2, E | E2, R | R1 | R2>
+  ) => Effect.Effect<A | A2, E2, R | R1 | R2>
 >(3, (self, policy, orElse) =>
   core.flatMap(
     driver(policy),
@@ -1968,7 +1968,7 @@ const retryOrElse_EffectLoop = <A, E, R, R1, A1, A2, E2, R2>(
   self: Effect.Effect<A, E, R>,
   driver: Schedule.ScheduleDriver<A1, E, R1>,
   orElse: (e: E, out: A1) => Effect.Effect<A2, E2, R2>
-): Effect.Effect<A | A2, E | E2, R | R1 | R2> => {
+): Effect.Effect<A | A2, E2, R | R1 | R2> => {
   return core.catchAll(
     self,
     (e) =>

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "2.4.16"
+let moduleVersion = "2.4.18"
 
 export const getCurrentVersion = () => moduleVersion