effect 3.6.8 → 3.7.0

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.6.8";
+let moduleVersion = "3.7.0";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.6.8",
+  "version": "3.7.0",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Array.ts

@@ -1049,14 +1049,23 @@ export const insertAt: {
  * import { Array } from "effect"
  *
  * const letters = ['a', 'b', 'c', 'd']
- * const result = Array.replace(1, 'z')(letters)
+ * const result = Array.replace(letters, 1, 'z')
  * assert.deepStrictEqual(result, ['a', 'z', 'c', 'd'])
  *
  * @since 2.0.0
  */
 export const replace: {
-  <B>(i: number, b: B): <A>(self: Iterable<A>) => Array<A | B>
-  <A, B>(self: Iterable<A>, i: number, b: B): Array<A | B>
+  <B>(
+    i: number,
+    b: B
+  ): <A, S extends Iterable<A> = Iterable<A>>(
+    self: S
+  ) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    self: S,
+    i: number,
+    b: B
+  ): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
 } = dual(3, <A, B>(self: Iterable<A>, i: number, b: B): Array<A | B> => modify(self, i, () => b))
 
 /**
@@ -1072,8 +1081,15 @@ export const replace: {
  * @since 2.0.0
  */
 export const replaceOption: {
-  <B>(i: number, b: B): <A>(self: Iterable<A>) => Option<Array<A | B>>
-  <A, B>(self: Iterable<A>, i: number, b: B): Option<Array<A | B>>
+  <B>(
+    i: number,
+    b: B
+  ): <A, S extends Iterable<A> = Iterable<A>>(self: S) => Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    self: S,
+    i: number,
+    b: B
+  ): Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(
   3,
   <A, B>(self: Iterable<A>, i: number, b: B): Option<Array<A | B>> => modifyOption(self, i, () => b)
@@ -1093,8 +1109,15 @@ export const replaceOption: {
  * @since 2.0.0
  */
 export const modify: {
-  <A, B>(i: number, f: (a: A) => B): (self: Iterable<A>) => Array<A | B>
-  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    i: number,
+    f: (a: ReadonlyArray.Infer<S>) => B
+  ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    self: S,
+    i: number,
+    f: (a: ReadonlyArray.Infer<S>) => B
+  ): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
 } = dual(
   3,
   <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> =>
@@ -1118,8 +1141,15 @@ export const modify: {
  * @since 2.0.0
  */
 export const modifyOption: {
-  <A, B>(i: number, f: (a: A) => B): (self: Iterable<A>) => Option<Array<A | B>>
-  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option<Array<A | B>>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    i: number,
+    f: (a: ReadonlyArray.Infer<S>) => B
+  ): (self: S) => Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+  <A, B, S extends Iterable<A> = Iterable<A>>(
+    self: S,
+    i: number,
+    f: (a: ReadonlyArray.Infer<S>) => B
+  ): Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option<Array<A | B>> => {
   const out = Array.from(self)
   if (isOutOfBound(i, out)) {

package/src/Config.ts

@@ -367,6 +367,14 @@ export const hashSet: <A>(config: Config<A>, name?: string) => Config<HashSet.Ha
  */
 export const string: (name?: string) => Config<string> = internal.string
 
+/**
+ * Constructs a config for a non-empty string value.
+ *
+ * @since 3.7.0
+ * @category constructors
+ */
+export const nonEmptyString: (name?: string) => Config<string> = internal.nonEmptyString
+
 /**
  * Constructs a config which contains the specified value.
  *

package/src/Context.ts

@@ -8,6 +8,7 @@
  * @since 2.0.0
  */
 import type { Equal } from "./Equal.js"
+import type { LazyArg } from "./Function.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as internal from "./internal/context.js"
 import type { Option } from "./Option.js"
@@ -263,6 +264,18 @@ export const get: {
   <Services, T extends ValidTagsById<Services>>(self: Context<Services>, tag: T): Tag.Service<T>
 } = internal.get
 
+/**
+ * Get a service from the context that corresponds to the given tag, or
+ * use the fallback value.
+ *
+ * @since 3.7.0
+ * @category getters
+ */
+export const getOrElse: {
+  <S, I, B>(tag: Tag<I, S>, orElse: LazyArg<B>): <Services>(self: Context<Services>) => S | B
+  <Services, S, I, B>(self: Context<Services>, tag: Tag<I, S>, orElse: LazyArg<B>): S | B
+} = internal.getOrElse
+
 /**
  * Get a service from the context that corresponds to the given tag.
  * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown.

package/src/Effect.ts

@@ -484,6 +484,7 @@ export const all: <
     readonly batching?: boolean | "inherit" | undefined
     readonly discard?: boolean | undefined
     readonly mode?: "default" | "validate" | "either" | undefined
+    readonly concurrentFinalizers?: boolean | undefined
   }
 >(arg: Arg, options?: O) => All.Return<Arg, O> = fiberRuntime.all
 
@@ -503,6 +504,7 @@ export const allWith: <
     readonly batching?: boolean | "inherit" | undefined
     readonly discard?: boolean | undefined
     readonly mode?: "default" | "validate" | "either" | undefined
+    readonly concurrentFinalizers?: boolean | undefined
   }
 >(
   options?: O
@@ -602,6 +604,7 @@ export declare namespace All {
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: boolean | undefined
       readonly mode?: "default" | "validate" | "either" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   > = [Arg] extends [ReadonlyArray<EffectAny>] ? ReturnTuple<Arg, IsDiscard<O>, ExtractMode<O>>
     : [Arg] extends [Iterable<EffectAny>] ? ReturnIterable<Arg, IsDiscard<O>, ExtractMode<O>>
@@ -622,6 +625,7 @@ export const allSuccesses: <X extends Effect<any, any, any>>(
     | {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
     | undefined
 ) => Effect<Array<Effect.Success<X>>, never, Effect.Context<X>> = fiberRuntime.allSuccesses
@@ -678,6 +682,7 @@ export const exists: {
       | {
         readonly concurrency?: Concurrency | undefined
         readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
       }
       | undefined
   ): (elements: Iterable<A>) => Effect<boolean, E, R>
@@ -688,6 +693,7 @@ export const exists: {
       | {
         readonly concurrency?: Concurrency | undefined
         readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
       }
       | undefined
   ): Effect<boolean, E, R>
@@ -706,6 +712,7 @@ export const filter: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly negate?: boolean | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): (elements: Iterable<A>) => Effect<Array<A>, E, R>
   <A, E, R>(
@@ -715,6 +722,7 @@ export const filter: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly negate?: boolean | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): Effect<Array<A>, E, R>
 } = fiberRuntime.filter
@@ -784,6 +792,7 @@ export const forEach: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): (
     self: S
@@ -794,6 +803,7 @@ export const forEach: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): (self: Iterable<A>) => Effect<void, E, R>
   <B, E, R, S extends Iterable<any>>(
@@ -803,6 +813,7 @@ export const forEach: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): Effect<RA.ReadonlyArray.With<S, B>, E, R>
   <A, B, E, R>(
@@ -812,6 +823,7 @@ export const forEach: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<void, E, R>
 } = fiberRuntime.forEach as any
@@ -838,7 +850,11 @@ export const mergeAll: {
     zero: Z,
     f: (z: Z, a: Effect.Success<Eff>, i: number) => Z,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): (elements: Iterable<Eff>) => Effect<Z, Effect.Error<Eff>, Effect.Context<Eff>>
   <Eff extends Effect<any, any, any>, Z>(
@@ -846,7 +862,11 @@ export const mergeAll: {
     zero: Z,
     f: (z: Z, a: Effect.Success<Eff>, i: number) => Z,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<Z, Effect.Error<Eff>, Effect.Context<Eff>>
 } = fiberRuntime.mergeAll
@@ -862,14 +882,22 @@ export const partition: {
   <A, B, E, R>(
     f: (a: A, i: number) => Effect<B, E, R>,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
   <A, B, E, R>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect<B, E, R>,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
 } = fiberRuntime.partition
@@ -897,7 +925,11 @@ export const reduceEffect: {
     zero: Effect<Z, E, R>,
     f: (acc: NoInfer<Z>, a: Effect.Success<Eff>, i: number) => Z,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): (elements: Iterable<Eff>) => Effect<Z, E | Effect.Error<Eff>, R | Effect.Context<Eff>>
   <Eff extends Effect<any, any, any>, Z, E, R>(
@@ -905,7 +937,11 @@ export const reduceEffect: {
     zero: Effect<Z, E, R>,
     f: (acc: NoInfer<Z>, a: Effect.Success<Eff>, i: number) => Z,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<Z, E | Effect.Error<Eff>, R | Effect.Context<Eff>>
 } = fiberRuntime.reduceEffect
@@ -965,6 +1001,7 @@ export const replicateEffect: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<Array<A>, E, R>
   (
@@ -973,6 +1010,7 @@ export const replicateEffect: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R>
   <A, E, R>(
@@ -982,6 +1020,7 @@ export const replicateEffect: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<Array<A>, E, R>
   <A, E, R>(
@@ -991,6 +1030,7 @@ export const replicateEffect: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<void, E, R>
 } = fiberRuntime.replicateEffect
@@ -1044,6 +1084,7 @@ export const validateAll: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): (elements: Iterable<A>) => Effect<Array<B>, Array<E>, R>
   <A, B, E, R>(
@@ -1052,6 +1093,7 @@ export const validateAll: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): (elements: Iterable<A>) => Effect<void, Array<E>, R>
   <A, B, E, R>(
@@ -1061,6 +1103,7 @@ export const validateAll: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard?: false | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): Effect<Array<B>, Array<E>, R>
   <A, B, E, R>(
@@ -1070,6 +1113,7 @@ export const validateAll: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly discard: true
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<void, Array<E>, R>
 } = fiberRuntime.validateAll
@@ -1098,14 +1142,22 @@ export const validateFirst: {
   <A, B, E, R>(
     f: (a: A, i: number) => Effect<B, E, R>,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): (elements: Iterable<A>) => Effect<B, Array<E>, R>
   <A, B, E, R>(
     elements: Iterable<A>,
     f: (a: A, i: number) => Effect<B, E, R>,
     options?:
-      | { readonly concurrency?: Concurrency | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrency?: Concurrency | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<B, Array<E>, R>
 } = fiberRuntime.validateFirst
@@ -3488,6 +3540,78 @@ export const bind: {
   ): Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
 } = effect.bind
 
+/**
+ * `bindAll` combines `Effect.all` with `Effect.bind`. It is useful
+ * when you want to concurrently run multiple effects and then combine their
+ * results in a Do notation pipeline.
+ *
+ * @example
+ * import { Effect, Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ *   Effect.Do,
+ *   Effect.bind("x", () => Effect.succeed(2)),
+ *   Effect.bindAll(({ x }) => ({
+ *     a: Effect.succeed(x),
+ *     b: Effect.fail("oops"),
+ *   }), { concurrency: 2, mode: "either" })
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") })
+ *
+ * @category do notation
+ * @since 3.7.0
+ */
+export const bindAll: {
+  <
+    A extends object,
+    X extends Record<string, Effect<any, any, any>>,
+    O extends {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly mode?: "default" | "validate" | "either" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
+    }
+  >(
+    f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
+    options?: undefined | O
+  ): <E1, R1>(
+    self: Effect<A, E1, R1>
+  ) => [All.ReturnObject<X, false, All.ExtractMode<O>>] extends [Effect<infer Success, infer Error, infer Context>]
+    ? Effect<
+      { [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never },
+      E1 | Error,
+      R1 | Context
+    >
+    : never
+  <
+    A extends object,
+    X extends Record<string, Effect<any, any, any>>,
+    O extends {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly mode?: "default" | "validate" | "either" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
+    },
+    E1,
+    R1
+  >(
+    self: Effect<A, E1, R1>,
+    f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
+    options?: undefined | {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly mode?: "default" | "validate" | "either" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
+    }
+  ): [All.ReturnObject<X, false, All.ExtractMode<O>>] extends [Effect<infer Success, infer Error, infer Context>]
+    ? Effect<
+      { [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never },
+      E1 | Error,
+      R1 | Context
+    >
+    : never
+} = circular.bindAll
+
 /**
  * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
  *
@@ -5347,19 +5471,20 @@ export const validate: {
   <B, E1, R1>(
     that: Effect<B, E1, R1>,
     options?: {
-      /**
-       * @since 2.0.0
-       * @category supervision & fibers
-       */
       readonly concurrent?: boolean | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     } | undefined
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, B], E1 | E, R1 | R>
   <A, E, R, B, E1, R1>(
     self: Effect<A, E, R>,
     that: Effect<B, E1, R1>,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<[A, B], E | E1, R | R1>
 } = fiberRuntime.validate
@@ -5376,7 +5501,11 @@ export const validateWith: {
     that: Effect<B, E1, R1>,
     f: (a: A, b: B) => C,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): <E, R>(self: Effect<A, E, R>) => Effect<C, E1 | E, R1 | R>
   <A, E, R, B, E1, R1, C>(
@@ -5384,7 +5513,11 @@ export const validateWith: {
     that: Effect<B, E1, R1>,
     f: (a: A, b: B) => C,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<C, E | E1, R | R1>
 } = fiberRuntime.validateWith
@@ -5446,14 +5579,22 @@ export const zip: {
   <A2, E2, R2>(
     that: Effect<A2, E2, R2>,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<[A, A2], E2 | E, R2 | R>
   <A, E, R, A2, E2, R2>(
     self: Effect<A, E, R>,
     that: Effect<A2, E2, R2>,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<[A, A2], E | E2, R | R2>
 } = fiberRuntime.zipOptions
@@ -5482,14 +5623,22 @@ export const zipLeft: {
   <A2, E2, R2>(
     that: Effect<A2, E2, R2>,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R2 | R>
   <A, E, R, A2, E2, R2>(
     self: Effect<A, E, R>,
     that: Effect<A2, E2, R2>,
     options?:
-      | { readonly concurrent?: boolean | undefined; readonly batching?: boolean | "inherit" | undefined }
+      | {
+        readonly concurrent?: boolean | undefined
+        readonly batching?: boolean | "inherit" | undefined
+        readonly concurrentFinalizers?: boolean | undefined
+      }
       | undefined
   ): Effect<A, E | E2, R | R2>
 } = fiberRuntime.zipLeftOptions
@@ -5520,6 +5669,7 @@ export const zipRight: {
     options?: {
       readonly concurrent?: boolean | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A2, E2 | E, R2 | R>
   <A, E, R, A2, E2, R2>(
@@ -5528,6 +5678,7 @@ export const zipRight: {
     options?: {
       readonly concurrent?: boolean | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<A2, E2 | E, R2 | R>
 } = fiberRuntime.zipRightOptions
@@ -5572,6 +5723,7 @@ export const zipWith: {
     options?: {
       readonly concurrent?: boolean | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R2 | R>
   <A, E, R, A2, E2, R2, B>(
@@ -5581,6 +5733,7 @@ export const zipWith: {
     options?: {
       readonly concurrent?: boolean | undefined
       readonly batching?: boolean | "inherit" | undefined
+      readonly concurrentFinalizers?: boolean | undefined
     }
   ): Effect<B, E2 | E, R2 | R>
 } = fiberRuntime.zipWithOptions

package/src/Fiber.ts

@@ -275,7 +275,14 @@ export {
  * @since 2.0.0
  * @category destructors
  */
-export const awaitAll: (fibers: Iterable<Fiber<any, any>>) => Effect.Effect<void> = fiberRuntime.fiberAwaitAll
+export const awaitAll: <const T extends Iterable<Fiber<any, any>>>(
+  fibers: T
+) => Effect.Effect<
+  [T] extends [ReadonlyArray<infer U>]
+    ? number extends T["length"] ? Array<U extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never>
+    : { -readonly [K in keyof T]: T[K] extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never }
+    : Array<T extends Iterable<infer U> ? U extends Fiber<infer A, infer E> ? Exit.Exit<A, E> : never : never>
+> = fiberRuntime.fiberAwaitAll
 
 /**
  * Retrieves the immediate children of the fiber.