effect 2.0.0-next.54 → 2.0.0-next.56

package/src/internal/fiberRuntime.ts

@@ -1,71 +1,71 @@
-import * as Boolean from "../Boolean"
-import type * as Cause from "../Cause"
-import * as Chunk from "../Chunk"
-import type * as Clock from "../Clock"
-import type { ConfigProvider } from "../ConfigProvider"
-import * as Context from "../Context"
-import * as Deferred from "../Deferred"
-import type * as Effect from "../Effect"
-import { EffectTypeId } from "../Effectable"
-import type * as Either from "../Either"
-import * as ExecutionStrategy from "../ExecutionStrategy"
-import type * as Exit from "../Exit"
-import type * as Fiber from "../Fiber"
-import * as FiberId from "../FiberId"
-import type * as FiberRef from "../FiberRef"
-import * as FiberRefs from "../FiberRefs"
-import * as FiberRefsPatch from "../FiberRefsPatch"
-import * as FiberStatus from "../FiberStatus"
-import type { LazyArg } from "../Function"
-import { dual, identity, pipe } from "../Function"
-import { globalValue } from "../GlobalValue"
-import * as HashMap from "../HashMap"
-import * as HashSet from "../HashSet"
-import * as _RequestBlock from "../internal/blockedRequests"
-import * as internalCause from "../internal/cause"
-import * as clock from "../internal/clock"
-import { currentRequestMap } from "../internal/completedRequestMap"
-import * as concurrency from "../internal/concurrency"
-import { configProviderTag } from "../internal/configProvider"
-import * as core from "../internal/core"
-import * as internalEffect from "../internal/core-effect"
-import * as defaultServices from "../internal/defaultServices"
-import { consoleTag } from "../internal/defaultServices/console"
-import * as executionStrategy from "../internal/executionStrategy"
-import * as internalFiber from "../internal/fiber"
-import * as FiberMessage from "../internal/fiberMessage"
-import * as fiberRefs from "../internal/fiberRefs"
-import * as fiberScope from "../internal/fiberScope"
-import * as internalLogger from "../internal/logger"
-import * as metric from "../internal/metric"
-import * as metricBoundaries from "../internal/metric/boundaries"
-import * as metricLabel from "../internal/metric/label"
-import * as OpCodes from "../internal/opCodes/effect"
-import { complete } from "../internal/request"
-import * as _runtimeFlags from "../internal/runtimeFlags"
-import { OpSupervision } from "../internal/runtimeFlags"
-import * as supervisor from "../internal/supervisor"
-import * as SupervisorPatch from "../internal/supervisor/patch"
-import * as tracer from "../internal/tracer"
-import type { Logger } from "../Logger"
-import * as LogLevel from "../LogLevel"
-import type * as MetricLabel from "../MetricLabel"
-import * as MRef from "../MutableRef"
-import * as Option from "../Option"
-import { pipeArguments } from "../Pipeable"
-import * as Predicate from "../Predicate"
-import * as RA from "../ReadonlyArray"
-import * as Ref from "../Ref"
-import type { Entry, Request } from "../Request"
-import type * as RequestBlock from "../RequestBlock"
-import type * as RuntimeFlags from "../RuntimeFlags"
-import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch"
-import { currentScheduler, type Scheduler } from "../Scheduler"
-import type * as Scope from "../Scope"
-import type * as Supervisor from "../Supervisor"
-import type * as Tracer from "../Tracer"
-import type { Concurrency } from "../Types"
-import { moduleVersion } from "./version"
+import * as Boolean from "../Boolean.js"
+import type * as Cause from "../Cause.js"
+import * as Chunk from "../Chunk.js"
+import type * as Clock from "../Clock.js"
+import type { ConfigProvider } from "../ConfigProvider.js"
+import * as Context from "../Context.js"
+import * as Deferred from "../Deferred.js"
+import type * as Effect from "../Effect.js"
+import { EffectTypeId } from "../Effectable.js"
+import type * as Either from "../Either.js"
+import * as ExecutionStrategy from "../ExecutionStrategy.js"
+import type * as Exit from "../Exit.js"
+import type * as Fiber from "../Fiber.js"
+import * as FiberId from "../FiberId.js"
+import type * as FiberRef from "../FiberRef.js"
+import * as FiberRefs from "../FiberRefs.js"
+import * as FiberRefsPatch from "../FiberRefsPatch.js"
+import * as FiberStatus from "../FiberStatus.js"
+import type { LazyArg } from "../Function.js"
+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 type { Logger } from "../Logger.js"
+import * as LogLevel from "../LogLevel.js"
+import type * as MetricLabel from "../MetricLabel.js"
+import * as MRef from "../MutableRef.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import * as Predicate from "../Predicate.js"
+import * as RA from "../ReadonlyArray.js"
+import * as Ref from "../Ref.js"
+import type { Entry, Request } from "../Request.js"
+import type * as RequestBlock from "../RequestBlock.js"
+import type * as RuntimeFlags from "../RuntimeFlags.js"
+import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
+import { currentScheduler, type Scheduler } from "../Scheduler.js"
+import type * as Scope from "../Scope.js"
+import type * as Supervisor from "../Supervisor.js"
+import type * as Tracer from "../Tracer.js"
+import type { Concurrency } from "../Types.js"
+import * as _RequestBlock from "./blockedRequests.js"
+import * as internalCause from "./cause.js"
+import * as clock from "./clock.js"
+import { currentRequestMap } from "./completedRequestMap.js"
+import * as concurrency from "./concurrency.js"
+import { configProviderTag } from "./configProvider.js"
+import * as internalEffect from "./core-effect.js"
+import * as core from "./core.js"
+import * as defaultServices from "./defaultServices.js"
+import { consoleTag } from "./defaultServices/console.js"
+import * as executionStrategy from "./executionStrategy.js"
+import * as internalFiber from "./fiber.js"
+import * as FiberMessage from "./fiberMessage.js"
+import * as fiberRefs from "./fiberRefs.js"
+import * as fiberScope from "./fiberScope.js"
+import * as internalLogger from "./logger.js"
+import * as metric from "./metric.js"
+import * as metricBoundaries from "./metric/boundaries.js"
+import * as metricLabel from "./metric/label.js"
+import * as OpCodes from "./opCodes/effect.js"
+import { complete } from "./request.js"
+import * as _runtimeFlags from "./runtimeFlags.js"
+import { OpSupervision } from "./runtimeFlags.js"
+import * as supervisor from "./supervisor.js"
+import * as SupervisorPatch from "./supervisor/patch.js"
+import * as tracer from "./tracer.js"
+import { moduleVersion } from "./version.js"
 
 /** @internal */
 export const fiberStarted = metric.counter("effect_fiber_started")
@@ -121,7 +121,7 @@ export const runtimeFiberVariance = {
 
 const absurd = (_: never): never => {
   throw new Error(
-    `BUG: FiberRuntime - ${JSON.stringify(_)} - please report an issue at https://github.com/Effect-TS/io/issues`
+    `BUG: FiberRuntime - ${JSON.stringify(_)} - please report an issue at https://github.com/Effect-TS/effect/issues`
   )
 }
 
@@ -238,9 +238,8 @@ const runBlockedRequests = <R>(self: RequestBlock.RequestBlock<R>) =>
   )
 
 /** @internal */
-export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
+export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A> {
   readonly [internalFiber.FiberTypeId] = internalFiber.fiberVariance
-
   readonly [internalFiber.RuntimeFiberTypeId] = runtimeFiberVariance
 
   pipe() {
@@ -303,14 +302,14 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
   /**
    * The status of the fiber.
    */
-  status(): Effect.Effect<never, never, FiberStatus.FiberStatus> {
+  get status(): Effect.Effect<never, never, FiberStatus.FiberStatus> {
     return this.ask((_, status) => status)
   }
 
   /**
    * Gets the fiber runtime flags.
    */
-  runtimeFlags(): Effect.Effect<never, never, RuntimeFlags.RuntimeFlags> {
+  get runtimeFlags(): Effect.Effect<never, never, RuntimeFlags.RuntimeFlags> {
     return this.ask((state, status) => {
       if (FiberStatus.isDone(status)) {
         return state._runtimeFlags
@@ -329,7 +328,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
   /**
    * Retrieves the immediate children of the fiber.
    */
-  children(): Effect.Effect<never, never, Array<Fiber.RuntimeFiber<any, any>>> {
+  get children(): Effect.Effect<never, never, Array<Fiber.RuntimeFiber<any, any>>> {
     return this.ask((fiber) => Array.from(fiber.getChildren()))
   }
 
@@ -394,7 +393,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
     }
   }
 
-  await(): Effect.Effect<never, never, Exit.Exit<E, A>> {
+  get await(): Effect.Effect<never, never, Exit.Exit<E, A>> {
     return core.async<never, never, Exit.Exit<E, A>>((resume) => {
       const cb = (exit: Exit.Exit<E, A>) => resume(core.succeed(exit))
       this.tell(
@@ -416,7 +415,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
     }, this.id())
   }
 
-  inheritAll(): Effect.Effect<never, never, void> {
+  get inheritAll(): Effect.Effect<never, never, void> {
     return core.withFiberRuntime<never, never, void>((parentFiber, parentStatus) => {
       const parentFiberId = parentFiber.id()
       const parentFiberRefs = parentFiber.getFiberRefs()
@@ -443,7 +442,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
    * Tentatively observes the fiber, but returns immediately if it is not
    * already done.
    */
-  poll(): Effect.Effect<never, never, Option.Option<Exit.Exit<E, A>>> {
+  get poll(): Effect.Effect<never, never, Option.Option<Exit.Exit<E, A>>> {
     return core.sync(() => Option.fromNullable(this._exitValue))
   }
 
@@ -709,7 +708,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
       const body = () => {
         const next = it.next()
         if (!next.done) {
-          return core.asUnit(next.value.await())
+          return core.asUnit(next.value.await)
         } else {
           return core.sync(() => {
             isDone = true
@@ -1045,7 +1044,7 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
   }
 
   ["None"](_: core.Primitive & { _op: "None" }) {
-    return core.fail(internalCause.NoSuchElementException())
+    return core.fail(new core.NoSuchElementException())
   }
 
   ["Right"](op: core.Primitive & { _op: "Right" }) {
@@ -1313,23 +1312,22 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
             (e as core.Primitive)._op === OpCodes.OP_ASYNC
           ) {
             throw e
-          }
-          if (
+          } else if (
             (e as core.Primitive)._op === OpCodes.OP_SUCCESS ||
             (e as core.Primitive)._op === OpCodes.OP_FAILURE
           ) {
             return e as Exit.Exit<E, A>
-          }
-        } else {
-          if (core.isEffectError(e)) {
-            cur = core.exitFailCause(e.cause)
-          } else if (internalCause.isInterruptedException(e)) {
-            cur = core.exitFailCause(
-              internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
-            )
           } else {
             cur = core.exitFailCause(internalCause.die(e))
           }
+        } else if (core.isEffectError(e)) {
+          cur = core.exitFailCause(e.cause)
+        } else if (core.isInterruptedException(e)) {
+          cur = core.exitFailCause(
+            internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
+          )
+        } else {
+          cur = core.exitFailCause(internalCause.die(e))
         }
       }
     }
@@ -1412,6 +1410,24 @@ export const tracerLogger = globalValue(
     })
 )
 
+/** @internal */
+export const loggerWithSpanAnnotations = <Message, Output>(self: Logger<Message, Output>): Logger<Message, Output> =>
+  internalLogger.mapInputOptions(self, (options: Logger.Options<Message>) => {
+    const span = Option.flatMap(fiberRefs.get(options.context, core.currentContext), Context.getOption(tracer.spanTag))
+    if (span._tag === "None") {
+      return options
+    }
+    return {
+      ...options,
+      annotations: pipe(
+        options.annotations,
+        HashMap.set("effect.traceId", span.value.traceId as unknown),
+        HashMap.set("effect.spanId", span.value.spanId as unknown),
+        span.value._tag === "Span" ? HashMap.set("effect.spanName", span.value.name as unknown) : identity
+      )
+    }
+  })
+
 /** @internal */
 export const currentLoggers: FiberRef.FiberRef<
   HashSet.HashSet<Logger<unknown, any>>
@@ -1521,20 +1537,20 @@ const _existsParFound = Symbol.for("effect/Effect/existsPar/found")
 /* @internal */
 export const exists = dual<
   <R, E, A>(f: (a: A, i: number) => Effect.Effect<R, E, boolean>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => (elements: Iterable<A>) => Effect.Effect<R, E, boolean>,
   <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, boolean>, options?: {
-    readonly concurrency: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => Effect.Effect<R, E, boolean>
 >((args) => Predicate.isIterable(args[0]), (elements, f, options) =>
   concurrency.matchSimple(
-    options,
+    options?.concurrency,
     () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)),
     () =>
       core.matchEffect(
-        forEachOptions(
+        forEach(
           elements,
           (a, i) => core.if_(f(a, i), { onTrue: core.fail(_existsParFound), onFalse: core.unit }),
           options
@@ -1566,26 +1582,26 @@ export const filter = dual<
   <A, R, E>(
     f: (a: A, i: number) => Effect.Effect<R, E, boolean>,
     options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
-      readonly negate?: boolean
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly negate?: boolean | undefined
     }
   ) => (elements: Iterable<A>) => Effect.Effect<R, E, Array<A>>,
   <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, boolean>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly negate?: boolean
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly negate?: boolean | undefined
   }) => Effect.Effect<R, E, Array<A>>
 >(
   (args) => Predicate.isIterable(args[0]),
   <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, boolean>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly negate?: boolean
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly negate?: boolean | undefined
   }) => {
     const predicate = options?.negate ? (a: A, i: number) => core.map(f(a, i), Boolean.not) : f
     return concurrency.matchSimple(
-      options,
+      options?.concurrency,
       () =>
         core.suspend(() =>
           RA.fromIterable(elements).reduceRight(
@@ -1600,7 +1616,7 @@ export const filter = dual<
         ),
       () =>
         core.map(
-          forEachOptions(
+          forEach(
             elements,
             (a, i) => core.map(predicate(a, i), (b) => (b ? Option.some(a) : Option.none())),
             options
@@ -1615,7 +1631,7 @@ export const filter = dual<
 
 const allResolveInput = (
   input: Iterable<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>
-): readonly [Iterable<Effect.Effect<any, any, any>>, Option.Option<(as: ReadonlyArray<any>) => any>] => {
+): [Iterable<Effect.Effect<any, any, any>>, Option.Option<(as: ReadonlyArray<any>) => any>] => {
   if (Array.isArray(input) || Predicate.isIterable(input)) {
     return [input, Option.none()]
   }
@@ -1637,10 +1653,10 @@ const allValidate = (
   effects: Iterable<Effect.Effect<any, any, any>>,
   reconcile: Option.Option<(as: ReadonlyArray<any>) => any>,
   options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly discard?: boolean
-    readonly mode?: "default" | "validate" | "either"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
+    readonly mode?: "default" | "validate" | "either" | undefined
   }
 ) => {
   const eitherEffects: Array<Effect.Effect<unknown, never, Either.Either<unknown, unknown>>> = []
@@ -1648,7 +1664,7 @@ const allValidate = (
     eitherEffects.push(core.either(effect))
   }
   return core.flatMap(
-    forEachOptions(eitherEffects, identity, {
+    forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
       batching: options?.batching
     }),
@@ -1686,10 +1702,10 @@ const allEither = (
   effects: Iterable<Effect.Effect<any, any, any>>,
   reconcile: Option.Option<(as: ReadonlyArray<any>) => any>,
   options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly discard?: boolean
-    readonly mode?: "default" | "validate" | "either"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
+    readonly mode?: "default" | "validate" | "either" | undefined
   }
 ) => {
   const eitherEffects: Array<Effect.Effect<unknown, never, Either.Either<unknown, unknown>>> = []
@@ -1698,7 +1714,7 @@ const allEither = (
   }
 
   if (options?.discard) {
-    return forEachOptions(eitherEffects, identity, {
+    return forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
       batching: options?.batching,
       discard: true
@@ -1706,7 +1722,7 @@ const allEither = (
   }
 
   return core.map(
-    forEachOptions(eitherEffects, identity, {
+    forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
       batching: options?.batching
     }),
@@ -1721,10 +1737,10 @@ const allEither = (
 export const all = <
   const Arg extends Iterable<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>,
   O extends {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly discard?: boolean
-    readonly mode?: "default" | "validate" | "either"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
+    readonly mode?: "default" | "validate" | "either" | undefined
   }
 >(
   arg: Arg,
@@ -1740,19 +1756,19 @@ export const all = <
 
   return reconcile._tag === "Some"
     ? core.map(
-      forEachOptions(effects, identity, options as any),
+      forEach(effects, identity, options as any),
       reconcile.value
     ) as any
-    : forEachOptions(effects, identity, options as any) as any
+    : forEach(effects, identity, options as any) as any
 }
 
 /* @internal */
 export const allWith = <
   O extends {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly discard?: boolean
-    readonly mode?: "default" | "validate" | "either"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
+    readonly mode?: "default" | "validate" | "either" | undefined
   }
 >(options?: O) =>
 <const Arg extends Iterable<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>>(
@@ -1763,8 +1779,8 @@ export const allWith = <
 export const allSuccesses = <R, E, A>(
   elements: Iterable<Effect.Effect<R, E, A>>,
   options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }
 ): Effect.Effect<R, never, Array<A>> =>
   core.map(
@@ -1779,110 +1795,130 @@ export const replicate = dual<
 >(2, (self, n) => Array.from({ length: n }, () => self))
 
 /* @internal */
-export const replicateEffect = dual<
-  {
-    (n: number, options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
-      readonly discard?: false
-    }): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, Array<A>>
-    (n: number, options: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+export const replicateEffect: {
+  (
+    n: number,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly discard?: false | undefined
+    }
+  ): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, Array<A>>
+  (
+    n: number,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
-    }): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, void>
-  },
-  {
-    <R, E, A>(self: Effect.Effect<R, E, A>, n: number, options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
-      readonly discard?: false
-    }): Effect.Effect<R, E, Array<A>>
-    <R, E, A>(self: Effect.Effect<R, E, A>, n: number, options: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+    }
+  ): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, void>
+  <R, E, A>(
+    self: Effect.Effect<R, E, A>,
+    n: number,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly discard?: false | undefined
+    }
+  ): Effect.Effect<R, E, Array<A>>
+  <R, E, A>(
+    self: Effect.Effect<R, E, A>,
+    n: number,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
-    }): Effect.Effect<R, E, void>
-  }
->(
+    }
+  ): Effect.Effect<R, E, void>
+} = dual(
   (args) => core.isEffect(args[0]),
-  (self, n, options) =>
-    all(
-      replicate(self, n),
-      options as {
-        readonly concurrency?: Concurrency
-        readonly batching?: boolean | "inherit"
-        readonly discard?: boolean
-      }
-    )
+  (self, n, options) => all(replicate(self, n), options)
 )
 
-// @ts-expect-error
-export const forEachOptions = dual<
-  {
-    <A, R, E, B>(f: (a: A, i: number) => Effect.Effect<R, E, B>, options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
-      readonly discard?: false
-    }): (self: Iterable<A>) => Effect.Effect<R, E, Array<B>>
-    <A, R, E, B>(f: (a: A, i: number) => Effect.Effect<R, E, B>, options: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+/* @internal */
+export const forEach: {
+  <A, R, E, B>(
+    f: (a: A, i: number) => Effect.Effect<R, E, B>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly discard?: false | undefined
+    }
+  ): (self: Iterable<A>) => Effect.Effect<R, E, Array<B>>
+  <A, R, E, B>(
+    f: (a: A, i: number) => Effect.Effect<R, E, B>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
-    }): (self: Iterable<A>) => Effect.Effect<R, E, void>
-  },
-  {
-    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, B>, options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
-      readonly discard?: false
-    }): Effect.Effect<R, E, Array<B>>
-    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, B>, options: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+    }
+  ): (self: Iterable<A>) => Effect.Effect<R, E, void>
+  <A, R, E, B>(
+    self: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<R, E, B>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly discard?: false | undefined
+    }
+  ): Effect.Effect<R, E, Array<B>>
+  <A, R, E, B>(
+    self: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<R, E, B>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
-    }): Effect.Effect<R, E, void>
+    }
+  ): Effect.Effect<R, E, void>
+} = dual((args) => Predicate.isIterable(args[0]), <A, R, E, B>(
+  self: Iterable<A>,
+  f: (a: A, i: number) => Effect.Effect<R, E, B>,
+  options?: {
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
   }
->((args) => Predicate.isIterable(args[0]), (self, f, options) =>
-  core.withFiberRuntime((r) => {
-    const requestBatchingEnabled = options?.batching === true ||
+) =>
+  core.withFiberRuntime<R, E, A | void>((r) => {
+    const isRequestBatchingEnabled = options?.batching === true ||
       (options?.batching === "inherit" && r.getFiberRef(core.currentRequestBatching))
 
     if (options?.discard) {
       return concurrency.match(
-        options,
+        options.concurrency,
         () =>
           finalizersMask(ExecutionStrategy.sequential)((restore) =>
-            requestBatchingEnabled
+            isRequestBatchingEnabled
               ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i)))
               : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))
           ),
         () =>
           finalizersMask(ExecutionStrategy.parallel)((restore) =>
-            forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)
+            forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)
           ),
         (n) =>
           finalizersMask(ExecutionStrategy.parallelN(n))((restore) =>
-            forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)
+            forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)
           )
       )
     }
 
     return concurrency.match(
-      options,
+      options?.concurrency,
       () =>
         finalizersMask(ExecutionStrategy.sequential)((restore) =>
-          requestBatchingEnabled
+          isRequestBatchingEnabled
             ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true)
             : core.forEachSequential(self, (a, i) => restore(f(a, i)))
         ),
       () =>
         finalizersMask(ExecutionStrategy.parallel)((restore) =>
-          forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)
+          forEachParUnbounded(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)
         ),
       (n) =>
         finalizersMask(ExecutionStrategy.parallelN(n))((restore) =>
-          forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)
+          forEachParN(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)
         )
     )
   }))
@@ -2048,8 +2084,7 @@ export const forEachParUnboundedDiscard = <R, E, A, _>(
                   }
                 }
               ),
-            onSuccess: (rest) =>
-              core.flatMap(rest, () => core.forEachSequentialDiscard(joinOrder, (f) => f.inheritAll()))
+            onSuccess: (rest) => core.flatMap(rest, () => core.forEachSequentialDiscard(joinOrder, (f) => f.inheritAll))
           }
         ))
     })
@@ -2214,21 +2249,21 @@ const forkWithScopeOverride = <R, E, A>(
 /* @internal */
 export const mergeAll = dual<
   <Z, A>(zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => <R, E>(elements: Iterable<Effect.Effect<R, E, A>>) => Effect.Effect<R, E, Z>,
   <R, E, A, Z>(elements: Iterable<Effect.Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => Effect.Effect<R, E, Z>
 >(
   (args) => Predicate.isIterable(args[0]),
   <R, E, A, Z>(elements: Iterable<Effect.Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) =>
     concurrency.matchSimple(
-      options,
+      options?.concurrency,
       () =>
         RA.fromIterable(elements).reduce(
           (acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)),
@@ -2237,7 +2272,7 @@ export const mergeAll = dual<
       () =>
         core.flatMap(Ref.make(zero), (acc) =>
           core.flatMap(
-            forEachOptions(
+            forEach(
               elements,
               (effect, i) => core.flatMap(effect, (a) => Ref.update(acc, (b) => f(b, a, i))),
               options
@@ -2252,21 +2287,21 @@ export const partition = dual<
   <R, E, A, B>(
     f: (a: A, i: number) => Effect.Effect<R, E, B>,
     options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
-  ) => (elements: Iterable<A>) => Effect.Effect<R, never, readonly [Array<E>, Array<B>]>,
+  ) => (elements: Iterable<A>) => Effect.Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>,
   <R, E, A, B>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect.Effect<R, E, B>,
     options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
-  ) => Effect.Effect<R, never, readonly [Array<E>, Array<B>]>
+  ) => Effect.Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>
 >((args) => Predicate.isIterable(args[0]), (elements, f, options) =>
   pipe(
-    forEachOptions(elements, (a, i) => core.either(f(a, i)), options),
+    forEach(elements, (a, i) => core.either(f(a, i)), options),
     core.map((chunk) => core.partitionMap(chunk, identity))
   ))
 
@@ -2276,16 +2311,16 @@ export const validateAll = dual<
     <R, E, A, B>(
       f: (a: A, i: number) => Effect.Effect<R, E, B>,
       options?: {
-        readonly concurrency?: Concurrency
-        readonly batching?: boolean | "inherit"
-        readonly discard?: false
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly discard?: false | undefined
       }
     ): (elements: Iterable<A>) => Effect.Effect<R, Array<E>, Array<B>>
     <R, E, A, B>(
       f: (a: A, i: number) => Effect.Effect<R, E, B>,
       options: {
-        readonly concurrency?: Concurrency
-        readonly batching?: boolean | "inherit"
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
         readonly discard: true
       }
     ): (elements: Iterable<A>) => Effect.Effect<R, Array<E>, void>
@@ -2295,17 +2330,17 @@ export const validateAll = dual<
       elements: Iterable<A>,
       f: (a: A, i: number) => Effect.Effect<R, E, B>,
       options?: {
-        readonly concurrency?: Concurrency
-        readonly batching?: boolean | "inherit"
-        readonly discard?: false
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly discard?: false | undefined
       }
     ): Effect.Effect<R, Array<E>, Array<B>>
     <R, E, A, B>(
       elements: Iterable<A>,
       f: (a: A, i: number) => Effect.Effect<R, E, B>,
       options: {
-        readonly concurrency?: Concurrency
-        readonly batching?: boolean | "inherit"
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
         readonly discard: true
       }
     ): Effect.Effect<R, Array<E>, void>
@@ -2313,9 +2348,9 @@ export const validateAll = dual<
 >(
   (args) => Predicate.isIterable(args[0]),
   <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, B>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
-    readonly discard?: boolean
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
+    readonly discard?: boolean | undefined
   }): Effect.Effect<R, Array<E>, any> =>
     core.flatMap(
       partition(elements, f, {
@@ -2333,7 +2368,7 @@ export const validateAll = dual<
 export const raceAll = <R, E, A>(all: Iterable<Effect.Effect<R, E, A>>) => {
   const list = Chunk.fromIterable(all)
   if (!Chunk.isNonEmpty(list)) {
-    return core.dieSync(() => internalCause.IllegalArgumentException(`Received an empty collection of effects`))
+    return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
   }
   const self = Chunk.headNonEmpty(list)
   const effects = Chunk.tailNonEmpty(list)
@@ -2444,8 +2479,8 @@ export const reduceEffect = dual<
     zero: Effect.Effect<R, E, A>,
     f: (acc: A, a: A, i: number) => A,
     options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => (elements: Iterable<Effect.Effect<R, E, A>>) => Effect.Effect<R, E, A>,
   <R, E, A>(
@@ -2453,8 +2488,8 @@ export const reduceEffect = dual<
     zero: Effect.Effect<R, E, A>,
     f: (acc: A, a: A, i: number) => A,
     options?: {
-      readonly concurrency?: Concurrency
-      readonly batching?: boolean | "inherit"
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R, E, A>
 >((args) => Predicate.isIterable(args[0]), <R, E, A>(
@@ -2462,12 +2497,12 @@ export const reduceEffect = dual<
   zero: Effect.Effect<R, E, A>,
   f: (acc: A, a: A, i: number) => A,
   options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }
 ) =>
   concurrency.matchSimple(
-    options,
+    options?.concurrency,
     () => RA.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), zero),
     () =>
       core.suspend(() =>
@@ -2491,7 +2526,7 @@ export const reduceEffect = dual<
             switch (option._tag) {
               case "None": {
                 throw new Error(
-                  "BUG: Effect.reduceEffect - please report an issue at https://github.com/Effect-TS/io/issues"
+                  "BUG: Effect.reduceEffect - please report an issue at https://github.com/Effect-TS/effect/issues"
                 )
               }
               case "Some": {
@@ -2632,16 +2667,16 @@ export const validate = dual<
   <R1, E1, B>(
     that: Effect.Effect<R1, E1, B>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E1, [A, B]>,
   <R, E, A, R1, E1, B>(
     self: Effect.Effect<R, E, A>,
     that: Effect.Effect<R1, E1, B>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R1, E | E1, [A, B]>
 >(
@@ -2655,8 +2690,8 @@ export const validateWith = dual<
     that: Effect.Effect<R1, E1, B>,
     f: (a: A, b: B) => C,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E1, C>,
   <R, E, A, R1, E1, B, C>(
@@ -2664,8 +2699,8 @@ export const validateWith = dual<
     that: Effect.Effect<R1, E1, B>,
     f: (a: A, b: B) => C,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R1, E | E1, C>
 >((args) => core.isEffect(args[1]), (self, that, f, options) =>
@@ -2716,16 +2751,16 @@ export const validateAllParDiscard = dual<
 /* @internal */
 export const validateFirst = dual<
   <R, E, A, B>(f: (a: A, i: number) => Effect.Effect<R, E, B>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => (elements: Iterable<A>) => Effect.Effect<R, Array<E>, B>,
   <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, B>, options?: {
-    readonly concurrency?: Concurrency
-    readonly batching?: boolean | "inherit"
+    readonly concurrency?: Concurrency | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }) => Effect.Effect<R, Array<E>, B>
 >(
   (args) => Predicate.isIterable(args[0]),
-  (elements, f, options) => core.flip(forEachOptions(elements, (a, i) => core.flip(f(a, i)), options))
+  (elements, f, options) => core.flip(forEach(elements, (a, i) => core.flip(f(a, i)), options))
 )
 
 /* @internal */
@@ -2739,18 +2774,16 @@ export const withConfigProviderScoped = (value: ConfigProvider) =>
 /* @internal */
 export const withEarlyRelease = <R, E, A>(
   self: Effect.Effect<R, E, A>
-): Effect.Effect<R | Scope.Scope, E, readonly [Effect.Effect<never, never, void>, A]> =>
+): Effect.Effect<R | Scope.Scope, E, [Effect.Effect<never, never, void>, A]> =>
   scopeWith((parent) =>
     core.flatMap(core.scopeFork(parent, executionStrategy.sequential), (child) =>
       pipe(
         self,
         scopeExtend(child),
-        core.map((value) =>
-          [
-            core.fiberIdWith((fiberId) => core.scopeClose(child, core.exitInterrupt(fiberId))),
-            value
-          ] as const
-        )
+        core.map((value) => [
+          core.fiberIdWith((fiberId) => core.scopeClose(child, core.exitInterrupt(fiberId))),
+          value
+        ])
       ))
   )
 
@@ -2759,8 +2792,8 @@ export const zipOptions = dual<
   <R2, E2, A2>(
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E, A>(
     self: Effect.Effect<R, E, A>
@@ -2769,8 +2802,8 @@ export const zipOptions = dual<
     self: Effect.Effect<R, E, A>,
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R2, E | E2, [A, A2]>
 >((args) => core.isEffect(args[1]), (
@@ -2784,8 +2817,8 @@ export const zipLeftOptions = dual<
   <R2, E2, A2>(
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E, A>(
     self: Effect.Effect<R, E, A>
@@ -2794,8 +2827,8 @@ export const zipLeftOptions = dual<
     self: Effect.Effect<R, E, A>,
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R2, E | E2, A>
 >(
@@ -2808,16 +2841,16 @@ export const zipRightOptions = dual<
   <R2, E2, A2>(
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A2>,
   <R, E, A, R2, E2, A2>(
     self: Effect.Effect<R, E, A>,
     that: Effect.Effect<R2, E2, A2>,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R2, E | E2, A2>
 >((args) => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options))
@@ -2828,8 +2861,8 @@ export const zipWithOptions = dual<
     that: Effect.Effect<R2, E2, A2>,
     f: (a: A, b: A2) => B,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => <R, E>(
     self: Effect.Effect<R, E, A>
@@ -2839,8 +2872,8 @@ export const zipWithOptions = dual<
     that: Effect.Effect<R2, E2, A2>,
     f: (a: A, b: A2) => B,
     options?: {
-      readonly concurrent?: boolean
-      readonly batching?: boolean | "inherit"
+      readonly concurrent?: boolean | undefined
+      readonly batching?: boolean | "inherit" | undefined
     }
   ) => Effect.Effect<R | R2, E | E2, B>
 >((args) => core.isEffect(args[1]), <R, E, A, R2, E2, A2, B>(
@@ -2848,8 +2881,8 @@ export const zipWithOptions = dual<
   that: Effect.Effect<R2, E2, A2>,
   f: (a: A, b: A2) => B,
   options?: {
-    readonly concurrent?: boolean
-    readonly batching?: boolean | "inherit"
+    readonly concurrent?: boolean | undefined
+    readonly batching?: boolean | "inherit" | undefined
   }
 ): Effect.Effect<R | R2, E | E2, B> =>
   core.map(
@@ -3041,8 +3074,8 @@ export const fiberRefLocallyScopedWith = dual<
 export const fiberRefMake = <A>(
   initial: A,
   options?: {
-    readonly fork?: (a: A) => A
-    readonly join?: (left: A, right: A) => A
+    readonly fork?: ((a: A) => A) | undefined
+    readonly join?: ((left: A, right: A) => A) | undefined
   }
 ): Effect.Effect<Scope.Scope, never, FiberRef.FiberRef<A>> =>
   fiberRefMakeWith(() => core.fiberRefUnsafeMake(initial, options))
@@ -3088,38 +3121,37 @@ export const fiberAwaitAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.E
 export const fiberAll = <E, A>(fibers: Iterable<Fiber.Fiber<E, A>>): Fiber.Fiber<E, Array<A>> => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
-  await: () => core.exit(forEachParUnbounded(fibers, (fiber) => core.flatten(fiber.await()), false)),
-  children: () => core.map(forEachParUnbounded(fibers, (fiber) => fiber.children(), false), RA.flatten),
-  inheritAll: () => core.forEachSequentialDiscard(fibers, (fiber) => fiber.inheritAll()),
-  poll: () =>
-    core.map(
-      core.forEachSequential(fibers, (fiber) => fiber.poll()),
-      RA.reduceRight(
-        Option.some<Exit.Exit<E, Array<A>>>(core.exitSucceed(new Array())),
-        (optionB, optionA) => {
-          switch (optionA._tag) {
-            case "None": {
-              return Option.none()
-            }
-            case "Some": {
-              switch (optionB._tag) {
-                case "None": {
-                  return Option.none()
-                }
-                case "Some": {
-                  return Option.some(
-                    core.exitZipWith(optionA.value, optionB.value, {
-                      onSuccess: (a, chunk) => [a, ...chunk],
-                      onFailure: internalCause.parallel
-                    })
-                  )
-                }
+  await: core.exit(forEachParUnbounded(fibers, (fiber) => core.flatten(fiber.await), false)),
+  children: core.map(forEachParUnbounded(fibers, (fiber) => fiber.children, false), RA.flatten),
+  inheritAll: core.forEachSequentialDiscard(fibers, (fiber) => fiber.inheritAll),
+  poll: core.map(
+    core.forEachSequential(fibers, (fiber) => fiber.poll),
+    RA.reduceRight(
+      Option.some<Exit.Exit<E, Array<A>>>(core.exitSucceed(new Array())),
+      (optionB, optionA) => {
+        switch (optionA._tag) {
+          case "None": {
+            return Option.none()
+          }
+          case "Some": {
+            switch (optionB._tag) {
+              case "None": {
+                return Option.none()
+              }
+              case "Some": {
+                return Option.some(
+                  core.exitZipWith(optionA.value, optionB.value, {
+                    onSuccess: (a, chunk) => [a, ...chunk],
+                    onFailure: internalCause.parallel
+                  })
+                )
               }
             }
           }
         }
-      )
-    ),
+      }
+    )
+  ),
   interruptAsFork: (fiberId) => core.forEachSequentialDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId)),
   pipe() {
     return pipeArguments(this, arguments)
@@ -3169,11 +3201,11 @@ export const raceWith = dual<
 ) =>
   raceFibersWith(self, other, {
     onSelfWin: (winner, loser) =>
-      core.flatMap(winner.await(), (exit) => {
+      core.flatMap(winner.await, (exit) => {
         switch (exit._tag) {
           case OpCodes.OP_SUCCESS: {
             return core.flatMap(
-              winner.inheritAll(),
+              winner.inheritAll,
               () => options.onSelfDone(exit, loser)
             )
           }
@@ -3183,11 +3215,11 @@ export const raceWith = dual<
         }
       }),
     onOtherWin: (winner, loser) =>
-      core.flatMap(winner.await(), (exit) => {
+      core.flatMap(winner.await, (exit) => {
         switch (exit._tag) {
           case OpCodes.OP_SUCCESS: {
             return core.flatMap(
-              winner.inheritAll(),
+              winner.inheritAll,
               () => options.onOtherDone(exit, loser)
             )
           }
@@ -3271,8 +3303,8 @@ export const raceFibersWith = dual<
         winner: Fiber.RuntimeFiber<E1, A1>,
         loser: Fiber.RuntimeFiber<E, A>
       ) => Effect.Effect<R3, E3, A3>
-      readonly selfScope?: fiberScope.FiberScope
-      readonly otherScope?: fiberScope.FiberScope
+      readonly selfScope?: fiberScope.FiberScope | undefined
+      readonly otherScope?: fiberScope.FiberScope | undefined
     }
   ) => <R>(self: Effect.Effect<R, E, A>) => Effect.Effect<
     R | R1 | R2 | R3,
@@ -3291,8 +3323,8 @@ export const raceFibersWith = dual<
         winner: Fiber.RuntimeFiber<E1, A1>,
         loser: Fiber.RuntimeFiber<E, A>
       ) => Effect.Effect<R3, E3, A3>
-      readonly selfScope?: fiberScope.FiberScope
-      readonly otherScope?: fiberScope.FiberScope
+      readonly selfScope?: fiberScope.FiberScope | undefined
+      readonly otherScope?: fiberScope.FiberScope | undefined
     }
   ) => Effect.Effect<
     R | R1 | R2 | R3,
@@ -3311,8 +3343,8 @@ export const raceFibersWith = dual<
       winner: Fiber.RuntimeFiber<E1, A1>,
       loser: Fiber.RuntimeFiber<E, A>
     ) => Effect.Effect<R3, E3, A3>
-    readonly selfScope?: fiberScope.FiberScope
-    readonly otherScope?: fiberScope.FiberScope
+    readonly selfScope?: fiberScope.FiberScope | undefined
+    readonly otherScope?: fiberScope.FiberScope | undefined
   }
 ) =>
   core.withFiberRuntime<R | R1 | R2 | R3, E2 | E3, A2 | A3>((parentFiber, parentStatus) => {
@@ -3450,11 +3482,11 @@ export const interruptWhenPossible = dual<
 export const makeSpanScoped = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, unknown>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly context?: Context.Context<never>
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
   }
 ): Effect.Effect<Scope.Scope, never, Tracer.Span> =>
   acquireRelease(
@@ -3473,18 +3505,18 @@ export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<Scope.Scop
 /** @internal */
 export const withSpanScoped = dual<
   (name: string, options?: {
-    readonly attributes?: Record<string, unknown>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly context?: Context.Context<never>
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
   }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
-    readonly attributes?: Record<string, unknown>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly context?: Context.Context<never>
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
   }) => Effect.Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>
 >(
   (args) => typeof args[0] !== "string",