effect 3.11.1 → 3.11.3

package/dist/dts/Micro.d.ts

@@ -132,7 +132,15 @@ export declare const MicroCauseTypeId: unique symbol;
  */
 export type MicroCauseTypeId = typeof MicroCauseTypeId;
 /**
- * A Micro Cause is a data type that represents the different ways a Micro can fail.
+ * A `MicroCause` is a data type that represents the different ways a `Micro` can fail.
+ *
+ * **Details**
+ *
+ * `MicroCause` comes in three forms:
+ *
+ * - `Die`: Indicates an unforeseen defect that wasn't planned for in the system's logic.
+ * - `Fail`: Covers anticipated errors that are recognized and typically handled within the application.
+ * - `Interrupt`: Signifies an operation that has been purposefully stopped.
  *
  * @since 3.4.6
  * @experimental
@@ -255,22 +263,22 @@ export declare const causeWithTrace: {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export declare const FiberTypeId: unique symbol;
+export declare const MicroFiberTypeId: unique symbol;
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export type FiberTypeId = typeof FiberTypeId;
+export type MicroFiberTypeId = typeof MicroFiberTypeId;
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export interface Fiber<out A, out E = never> {
-    readonly [FiberTypeId]: Fiber.Variance<A, E>;
+export interface MicroFiber<out A, out E = never> {
+    readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>;
     readonly currentOpCount: number;
     readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A;
     readonly context: Context.Context<never>;
@@ -281,27 +289,27 @@ export interface Fiber<out A, out E = never> {
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export declare namespace Fiber {
+export declare namespace MicroFiber {
     /**
      * @since 3.11.0
      * @experimental
-     * @category Fiber
+     * @category MicroFiber
      */
     interface Variance<out A, out E = never> {
         readonly _A: Covariant<A>;
         readonly _E: Covariant<E>;
     }
 }
-declare class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
+declare class MicroFiberImpl<in out A = any, in out E = any> implements MicroFiber<A, E> {
     context: Context.Context<never>;
     interruptible: boolean;
-    readonly [FiberTypeId]: Fiber.Variance<A, E>;
+    readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>;
     readonly _stack: Array<Primitive>;
     readonly _observers: Array<(exit: MicroExit<A, E>) => void>;
     _exit: MicroExit<A, E> | undefined;
-    _children: Set<FiberImpl<any, any>> | undefined;
+    _children: Set<MicroFiberImpl<any, any>> | undefined;
     currentOpCount: number;
     constructor(context: Context.Context<never>, interruptible?: boolean);
     getRef<I, A>(ref: Context.Reference<I, A>): A;
@@ -311,29 +319,35 @@ declare class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
     unsafePoll(): MicroExit<A, E> | undefined;
     evaluate(effect: Primitive): void;
     runLoop(effect: Primitive): MicroExit<A, E> | Yield;
-    getCont<S extends successCont | failureCont>(symbol: S): (Primitive & Record<S, (value: any, fiber: FiberImpl) => Primitive>) | undefined;
+    getCont<S extends successCont | failureCont>(symbol: S): (Primitive & Record<S, (value: any, fiber: MicroFiberImpl) => Primitive>) | undefined;
     _yielded: MicroExit<any, any> | (() => void) | undefined;
     yieldWith(value: MicroExit<any, any> | (() => void)): Yield;
-    children(): Set<Fiber<any, any>>;
+    children(): Set<MicroFiber<any, any>>;
 }
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
+ */
+export declare const fiberAwait: <A, E>(self: MicroFiber<A, E>) => Micro<MicroExit<A, E>>;
+/**
+ * @since 3.11.2
+ * @experimental
+ * @category MicroFiber
  */
-export declare const fiberAwait: <A, E>(self: Fiber<A, E>) => Micro<MicroExit<A, E>>;
+export declare const fiberJoin: <A, E>(self: MicroFiber<A, E>) => Micro<A, E>;
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export declare const fiberInterrupt: <A, E>(self: Fiber<A, E>) => Micro<void>;
+export declare const fiberInterrupt: <A, E>(self: MicroFiber<A, E>) => Micro<void>;
 /**
  * @since 3.11.0
  * @experimental
- * @category Fiber
+ * @category MicroFiber
  */
-export declare const fiberInterruptAll: <A extends Iterable<Fiber<any, any>>>(fibers: A) => Micro<void>;
+export declare const fiberInterruptAll: <A extends Iterable<MicroFiber<any, any>>>(fibers: A) => Micro<void>;
 declare const identifier: unique symbol;
 type identifier = typeof identifier;
 declare const evaluate: unique symbol;
@@ -348,10 +362,10 @@ declare const Yield: unique symbol;
 type Yield = typeof Yield;
 interface Primitive {
     readonly [identifier]: string;
-    readonly [successCont]: ((value: unknown, fiber: FiberImpl) => Primitive | Yield) | undefined;
-    readonly [failureCont]: ((cause: MicroCause<unknown>, fiber: FiberImpl) => Primitive | Yield) | undefined;
-    readonly [ensureCont]: ((fiber: FiberImpl) => ((value: unknown, fiber: FiberImpl) => Primitive | Yield) | undefined) | undefined;
-    [evaluate](fiber: FiberImpl): Primitive | Yield;
+    readonly [successCont]: ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield) | undefined;
+    readonly [failureCont]: ((cause: MicroCause<unknown>, fiber: MicroFiberImpl) => Primitive | Yield) | undefined;
+    readonly [ensureCont]: ((fiber: MicroFiberImpl) => ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield) | undefined) | undefined;
+    [evaluate](fiber: MicroFiberImpl): Primitive | Yield;
 }
 /**
  * Creates a `Micro` effect that will succeed with the specified constant value.
@@ -370,10 +384,10 @@ export declare const succeed: <A>(value: A) => Micro<A>;
  */
 export declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>;
 /**
- * Creates a `Micro` effect that will fail with the specified error.
+ * Creates a `Micro` effect that fails with the given error.
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * This results in a `Fail` variant of the `MicroCause` type, where the error is
+ * tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -381,10 +395,10 @@ export declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>;
  */
 export declare const fail: <E>(error: E) => Micro<never, E>;
 /**
- * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ * Creates a `Micro` effect that succeeds with a lazily evaluated value.
  *
- * If the evaluation of the value throws an error, the effect will fail with
- * `CauseDie`.
+ * If the evaluation of the value throws an error, the effect will fail with a
+ * `Die` variant of the `MicroCause` type.
  *
  * @since 3.4.0
  * @experimental
@@ -418,7 +432,7 @@ export declare const yieldNowWith: (priority?: number) => Micro<void>;
  */
 export declare const yieldNow: Micro<void>;
 /**
- * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ * Creates a `Micro` effect that will succeed with the value wrapped in `Some`.
  *
  * @since 3.4.0
  * @experimental
@@ -426,7 +440,7 @@ export declare const yieldNow: Micro<void>;
  */
 export declare const succeedSome: <A>(a: A) => Micro<Option.Option<A>>;
 /**
- * Creates a `Micro` effect that will succeed with `Option.None`.
+ * Creates a `Micro` effect that succeeds with `None`.
  *
  * @since 3.4.0
  * @experimental
@@ -444,8 +458,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<MicroCause<E>>) => Mic
 /**
  * Creates a `Micro` effect that will die with the specified error.
  *
- * This will result in a `CauseDie`, where the error is not tracked at
- * the type level.
+ * This results in a `Die` variant of the `MicroCause` type, where the error is
+ * not tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -455,8 +469,8 @@ export declare const die: (defect: unknown) => Micro<never>;
 /**
  * Creates a `Micro` effect that will fail with the lazily evaluated error.
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * This results in a `Fail` variant of the `MicroCause` type, where the error is
+ * tracked at the type level.
  *
  * @since 3.4.6
  * @experimental
@@ -502,9 +516,6 @@ export {
  * The `Micro` equivalent of a try / catch block, which allows you to map
  * thrown errors to a specific error type.
  *
- * @since 3.4.0
- * @experimental
- * @category constructors
  * @example
  * ```ts
  * import { Micro } from "effect"
@@ -514,11 +525,17 @@ export {
  *   catch: (cause) => new Error("caught", { cause })
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
  */
 try_ as try };
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
- * `CauseDie`.
+ * Wrap a `Promise` into a `Micro` effect.
+ *
+ * Any errors will result in a `Die` variant of the `MicroCause` type, where the
+ * error is not tracked at the type level.
  *
  * @since 3.4.0
  * @experimental
@@ -529,9 +546,6 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
  * converted into a specific error type.
  *
- * @since 3.4.0
- * @experimental
- * @category constructors
  * @example
  * ```ts
  * import { Micro } from "effect"
@@ -541,19 +555,23 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  *   catch: (cause) => new Error("caught", { cause })
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
  */
 export declare const tryPromise: <A, E>(options: {
     readonly try: (signal: AbortSignal) => PromiseLike<A>;
     readonly catch: (error: unknown) => E;
 }) => Micro<A, E>;
 /**
- * Create a `Micro` effect using the current `Fiber`.
+ * Create a `Micro` effect using the current `MicroFiber`.
  *
  * @since 3.4.0
  * @experimental
  * @category constructors
  */
-export declare const withFiber: <A, E = never, R = never>(evaluate: (fiber: FiberImpl<A, E>) => Micro<A, E, R>) => Micro<A, E, R>;
+export declare const withMicroFiber: <A, E = never, R = never>(evaluate: (fiber: MicroFiberImpl<A, E>) => Micro<A, E, R>) => Micro<A, E, R>;
 /**
  * Flush any yielded effects that are waiting to be executed.
  *
@@ -618,7 +636,7 @@ export declare const as: {
     <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>;
 };
 /**
- * Wrap the success value of this `Micro` effect in an `Option.Some`.
+ * Wrap the success value of this `Micro` effect in a `Some`.
  *
  * @since 3.4.0
  * @experimental
@@ -634,11 +652,11 @@ export declare const asSome: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Opt
  */
 export declare const flip: <A, E, R>(self: Micro<A, E, R>) => Micro<E, A, R>;
 /**
- * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
- * a single api.
+ * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+ * single API.
  *
- * It also allows you to pass in a `Micro` effect directly, which will be
- * executed after the current effect.
+ * It also lets you directly pass a `Micro` effect, which will be executed after
+ * the current effect.
  *
  * @since 3.4.0
  * @experimental
@@ -646,11 +664,11 @@ export declare const flip: <A, E, R>(self: Micro<A, E, R>) => Micro<E, A, R>;
  */
 export declare const andThen: {
     /**
-     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-     * a single api.
+     * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+     * single API.
      *
-     * It also allows you to pass in a `Micro` effect directly, which will be
-     * executed after the current effect.
+     * It also lets you directly pass a `Micro` effect, which will be executed after
+     * the current effect.
      *
      * @since 3.4.0
      * @experimental
@@ -658,11 +676,11 @@ export declare const andThen: {
      */
     <A, X>(f: (a: A) => X): <E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
     /**
-     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-     * a single api.
+     * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+     * single API.
      *
-     * It also allows you to pass in a `Micro` effect directly, which will be
-     * executed after the current effect.
+     * It also lets you directly pass a `Micro` effect, which will be executed after
+     * the current effect.
      *
      * @since 3.4.0
      * @experimental
@@ -670,11 +688,11 @@ export declare const andThen: {
      */
     <X>(f: NotFunction<X>): <A, E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
     /**
-     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-     * a single api.
+     * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+     * single API.
      *
-     * It also allows you to pass in a `Micro` effect directly, which will be
-     * executed after the current effect.
+     * It also lets you directly pass a `Micro` effect, which will be executed after
+     * the current effect.
      *
      * @since 3.4.0
      * @experimental
@@ -682,11 +700,11 @@ export declare const andThen: {
      */
     <A, E, R, X>(self: Micro<A, E, R>, f: (a: A) => X): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
     /**
-     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-     * a single api.
+     * A more flexible version of `flatMap` that combines `map` and `flatMap` into a
+     * single API.
      *
-     * It also allows you to pass in a `Micro` effect directly, which will be
-     * executed after the current effect.
+     * It also lets you directly pass a `Micro` effect, which will be executed after
+     * the current effect.
      *
      * @since 3.4.0
      * @experimental
@@ -782,7 +800,7 @@ export declare const raceAll: <Eff extends Micro<any, any, any>>(all: Iterable<E
 /**
  * Returns an effect that races all the specified effects,
  * yielding the value of the first effect to succeed or fail. Losers of
- * the race will be interrupted immediately
+ * the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
@@ -791,7 +809,7 @@ export declare const raceAll: <Eff extends Micro<any, any, any>>(all: Iterable<E
 export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
 /**
  * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed. Losers of the race will be interrupted immediately
+ * effect to succeed. Losers of the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
@@ -800,7 +818,7 @@ export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Itera
 export declare const race: {
     /**
      * Returns an effect that races two effects, yielding the value of the first
-     * effect to succeed. Losers of the race will be interrupted immediately
+     * effect to succeed. Losers of the race will be interrupted immediately.
      *
      * @since 3.4.0
      * @experimental
@@ -809,7 +827,7 @@ export declare const race: {
     <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
     /**
      * Returns an effect that races two effects, yielding the value of the first
-     * effect to succeed. Losers of the race will be interrupted immediately
+     * effect to succeed. Losers of the race will be interrupted immediately.
      *
      * @since 3.4.0
      * @experimental
@@ -819,7 +837,7 @@ export declare const race: {
 };
 /**
  * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+ * effect to succeed *or* fail. Losers of the race will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
@@ -828,7 +846,7 @@ export declare const race: {
 export declare const raceFirst: {
     /**
      * Returns an effect that races two effects, yielding the value of the first
-     * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+     * effect to succeed *or* fail. Losers of the race will be interrupted immediately.
      *
      * @since 3.4.0
      * @experimental
@@ -837,7 +855,7 @@ export declare const raceFirst: {
     <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
     /**
      * Returns an effect that races two effects, yielding the value of the first
-     * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+     * effect to succeed *or* fail. Losers of the race will be interrupted immediately.
      *
      * @since 3.4.0
      * @experimental
@@ -910,10 +928,9 @@ export declare const map: {
     <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>;
 };
 /**
- * The MicroExit type is a data type that represents the result of a Micro
- * computation.
- *
- * It uses the `Either` data type to represent the success and failure cases.
+ * The `MicroExit` type is used to represent the result of a `Micro` computation. It
+ * can either be successful, containing a value of type `A`, or it can fail,
+ * containing an error of type `E` wrapped in a `MicroCause`.
  *
  * @since 3.4.6
  * @experimental
@@ -1044,7 +1061,7 @@ export declare const exitVoidAll: <I extends Iterable<MicroExit<any, any>>>(exit
  */
 export interface MicroScheduler {
     readonly scheduleTask: (task: () => void, priority: number) => void;
-    readonly shouldYield: (fiber: Fiber<unknown, unknown>) => boolean;
+    readonly shouldYield: (fiber: MicroFiber<unknown, unknown>) => boolean;
     readonly flush: () => void;
 }
 /**
@@ -1070,7 +1087,7 @@ export declare class MicroSchedulerDefault implements MicroScheduler {
     /**
      * @since 3.5.9
      */
-    shouldYield(fiber: Fiber<unknown, unknown>): boolean;
+    shouldYield(fiber: MicroFiber<unknown, unknown>): boolean;
     /**
      * @since 3.5.9
      */
@@ -1293,10 +1310,8 @@ export declare class CurrentScheduler extends CurrentScheduler_base {
  * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
  * api to control the concurrency of that `Micro` when it is run.
  *
- * @since 3.4.0
- * @experimental
- * @category environment refs
  * @example
+ * ```ts
  * import * as Micro from "effect/Micro"
  *
  * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
@@ -1304,16 +1319,19 @@ export declare class CurrentScheduler extends CurrentScheduler_base {
  * }).pipe(
  *   Micro.withConcurrency(2) // use a concurrency of 2
  * )
+ * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
  */
 export declare const withConcurrency: {
     /**
      * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
      * api to control the concurrency of that `Micro` when it is run.
      *
-     * @since 3.4.0
-     * @experimental
-     * @category environment refs
      * @example
+     * ```ts
      * import * as Micro from "effect/Micro"
      *
      * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
@@ -1321,16 +1339,19 @@ export declare const withConcurrency: {
      * }).pipe(
      *   Micro.withConcurrency(2) // use a concurrency of 2
      * )
+     * ```
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment refs
      */
     (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
     /**
      * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
      * api to control the concurrency of that `Micro` when it is run.
      *
-     * @since 3.4.0
-     * @experimental
-     * @category environment refs
      * @example
+     * ```ts
      * import * as Micro from "effect/Micro"
      *
      * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
@@ -1338,6 +1359,11 @@ export declare const withConcurrency: {
      * }).pipe(
      *   Micro.withConcurrency(2) // use a concurrency of 2
      * )
+     * ```
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment refs
      */
     <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>;
 };
@@ -1974,7 +2000,7 @@ export declare const catchCauseIf: {
 /**
  * Catch the error of the given `Micro` effect, allowing you to recover from it.
  *
- * It only catches expected (`MicroCause.Fail`) errors.
+ * It only catches expected errors.
  *
  * @since 3.4.6
  * @experimental
@@ -1984,7 +2010,7 @@ export declare const catchAll: {
     /**
      * Catch the error of the given `Micro` effect, allowing you to recover from it.
      *
-     * It only catches expected (`MicroCause.Fail`) errors.
+     * It only catches expected errors.
      *
      * @since 3.4.6
      * @experimental
@@ -1994,7 +2020,7 @@ export declare const catchAll: {
     /**
      * Catch the error of the given `Micro` effect, allowing you to recover from it.
      *
-     * It only catches expected (`MicroCause.Fail`) errors.
+     * It only catches expected errors.
      *
      * @since 3.4.6
      * @experimental
@@ -2965,9 +2991,6 @@ export declare const interruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A,
  * You can use the `restore` function to restore a `Micro` effect to the
  * interruptibility state before the `uninterruptibleMask` was applied.
  *
- * @since 3.4.0
- * @experimental
- * @category interruption
  * @example
  * ```ts
  * import * as Micro from "effect/Micro"
@@ -2978,6 +3001,10 @@ export declare const interruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A,
  *   )
  * )
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
  */
 export declare const uninterruptibleMask: <A, E, R>(f: (restore: <A_1, E_1, R_1>(effect: Micro<A_1, E_1, R_1>) => Micro<A_1, E_1, R_1>) => Micro<A, E, R>) => Micro<A, E, R>;
 /**
@@ -3053,13 +3080,14 @@ export declare const whileLoop: <A, E, R>(options: {
     readonly step: (a: A) => void;
 }) => Micro<void, E, R>;
 /**
- * For each element of the provided iterable, run the effect and collect the results.
+ * For each element of the provided iterable, run the effect and collect the
+ * results.
  *
  * If the `discard` option is set to `true`, the results will be discarded and
  * the effect will return `void`.
  *
- * The `concurrency` option can be set to control how many effects are run in
- * parallel. By default, the effects are run sequentially.
+ * The `concurrency` option can be set to control how many effects are run
+ * concurrently. By default, the effects are run sequentially.
  *
  * @since 3.4.0
  * @experimental
@@ -3067,13 +3095,14 @@ export declare const whileLoop: <A, E, R>(options: {
  */
 export declare const forEach: {
     /**
-     * For each element of the provided iterable, run the effect and collect the results.
+     * For each element of the provided iterable, run the effect and collect the
+     * results.
      *
      * If the `discard` option is set to `true`, the results will be discarded and
      * the effect will return `void`.
      *
-     * The `concurrency` option can be set to control how many effects are run in
-     * parallel. By default, the effects are run sequentially.
+     * The `concurrency` option can be set to control how many effects are run
+     * concurrently. By default, the effects are run sequentially.
      *
      * @since 3.4.0
      * @experimental
@@ -3084,13 +3113,14 @@ export declare const forEach: {
         readonly discard?: false | undefined;
     }): Micro<Array<B>, E, R>;
     /**
-     * For each element of the provided iterable, run the effect and collect the results.
+     * For each element of the provided iterable, run the effect and collect the
+     * results.
      *
      * If the `discard` option is set to `true`, the results will be discarded and
      * the effect will return `void`.
      *
-     * The `concurrency` option can be set to control how many effects are run in
-     * parallel. By default, the effects are run sequentially.
+     * The `concurrency` option can be set to control how many effects are run
+     * concurrently. By default, the effects are run sequentially.
      *
      * @since 3.4.0
      * @experimental
@@ -3104,7 +3134,8 @@ export declare const forEach: {
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental
@@ -3117,7 +3148,8 @@ export declare const filter: <A, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>)
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental
@@ -3210,82 +3242,79 @@ export {
  */
 let_ as let };
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * When the parent `Micro` finishes, this `Micro` will be aborted.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
-export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
+export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>;
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * It will not be aborted when the parent `Micro` finishes.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
-export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
+export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>;
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * The lifetime of the handle will be attached to the provided `MicroScope`.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
 export declare const forkIn: {
     /**
-     * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+     * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
      * aborted.
      *
      * The lifetime of the handle will be attached to the provided `MicroScope`.
      *
      * @since 3.4.0
      * @experimental
-     * @category handle & forking
+     * @category fiber & forking
      */
-    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
+    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>;
     /**
-     * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+     * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
      * aborted.
      *
      * The lifetime of the handle will be attached to the provided `MicroScope`.
      *
      * @since 3.4.0
      * @experimental
-     * @category handle & forking
+     * @category fiber & forking
      */
-    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R>;
+    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R>;
 };
 /**
- * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
  * aborted.
  *
  * The lifetime of the handle will be attached to the current `MicroScope`.
  *
  * @since 3.4.0
  * @experimental
- * @category handle & forking
+ * @category fiber & forking
  */
-export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R | MicroScope>;
+export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R | MicroScope>;
 /**
- * Execute the `Micro` effect and return a `Handle` that can be awaited, joined,
+ * Execute the `Micro` effect and return a `MicroFiber` that can be awaited, joined,
  * or aborted.
  *
  * You can listen for the result by adding an observer using the handle's
  * `addObserver` method.
  *
- * @since 3.4.0
- * @experimental
- * @category execution
  * @example
  * ```ts
  * import * as Micro from "effect/Micro"
@@ -3299,11 +3328,15 @@ export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<
  *   console.log(exit)
  * })
  * ```
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
  */
 export declare const runFork: <A, E>(effect: Micro<A, E>, options?: {
     readonly signal?: AbortSignal | undefined;
     readonly scheduler?: MicroScheduler | undefined;
-} | undefined) => FiberImpl<A, E>;
+} | undefined) => MicroFiberImpl<A, E>;
 /**
  * Execute the `Micro` effect and return a `Promise` that resolves with the
  * `MicroExit` of the computation.
@@ -3332,7 +3365,7 @@ export declare const runPromise: <A, E>(effect: Micro<A, E>, options?: {
  * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`.
  *
  * If any asynchronous effects are encountered, the function will return a
- * `CauseDie` containing the `Handle`.
+ * `CauseDie` containing the `MicroFiber`.
  *
  * @since 3.4.6
  * @experimental