effect 3.10.18 → 3.11.0

package/dist/dts/Micro.d.ts

@@ -1,23 +1,17 @@
-/**
- * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
- *
- * @since 3.4.0
- * @experimental
- */
-import type { Channel, ChannelTypeId } from "./Channel.js";
+import type { Channel } from "./Channel.js";
 import * as Context from "./Context.js";
-import type { Effect, EffectTypeId, EffectUnify, EffectUnifyIgnore } from "./Effect.js";
+import type { Effect, EffectUnify, EffectUnifyIgnore } from "./Effect.js";
+import * as Effectable from "./Effectable.js";
 import * as Either from "./Either.js";
-import { type LazyArg } from "./Function.js";
+import type { LazyArg } from "./Function.js";
 import type { TypeLambda } from "./HKT.js";
 import type { Inspectable } from "./Inspectable.js";
 import * as Option from "./Option.js";
-import { type Pipeable } from "./Pipeable.js";
-import { type Predicate, type Refinement } from "./Predicate.js";
-import type { ReadonlyRecord } from "./Record.js";
-import type { Sink, SinkTypeId } from "./Sink.js";
-import type { Stream, StreamTypeId } from "./Stream.js";
-import type { Concurrency, Covariant, Equals, NoInfer, NotFunction, Simplify } from "./Types.js";
+import type { Pipeable } from "./Pipeable.js";
+import type { Predicate, Refinement } from "./Predicate.js";
+import type { Sink } from "./Sink.js";
+import type { Stream } from "./Stream.js";
+import type { Concurrency, Covariant, Equals, NotFunction, Simplify } from "./Types.js";
 import type * as Unify from "./Unify.js";
 import { YieldWrap } from "./Utils.js";
 /**
@@ -35,15 +29,15 @@ export type TypeId = typeof TypeId;
 /**
  * @since 3.4.0
  * @experimental
- * @category symbols
+ * @category MicroExit
  */
-export declare const runSymbol: unique symbol;
+export declare const MicroExitTypeId: unique symbol;
 /**
  * @since 3.4.0
  * @experimental
- * @category symbols
+ * @category MicroExit
  */
-export type runSymbol = typeof runSymbol;
+export type MicroExitTypeId = typeof TypeId;
 /**
  * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
  *
@@ -53,7 +47,6 @@ export type runSymbol = typeof runSymbol;
  */
 export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
     readonly [TypeId]: Micro.Variance<A, E, R>;
-    [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void;
     [Symbol.iterator](): MicroIterator<Micro<A, E, R>>;
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: MicroUnify<this>;
@@ -126,32 +119,6 @@ export declare const isMicro: (u: unknown) => u is Micro<any, any, any>;
 export interface MicroIterator<T extends Micro<any, any, any>> {
     next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>;
 }
-/**
- * @since 3.8.4
- * @experimental
- * @category models
- */
-export interface MicroClass {
-    new <A, E = never, R = never>(): Micro<A, E, R>;
-}
-declare const MicroBase: MicroClass;
-/**
- * @since 3.8.4
- * @experimental
- * @category constructors
- */
-export declare abstract class Class<out A, out E = never, out R = never> extends MicroBase<A, E, R> {
-    /**
-     * @since 3.8.4
-     * @experimental
-     */
-    abstract asMicro(): Micro<A, E, R>;
-    /**
-     * @since 3.8.4
-     * @experimental
-     */
-    [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void;
-}
 /**
  * @since 3.4.6
  * @experimental
@@ -286,1080 +253,1093 @@ export declare const causeWithTrace: {
     <E>(self: MicroCause<E>, trace: string): MicroCause<E>;
 };
 /**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export declare namespace MicroExit {
-    /**
-     * @since 3.4.6
-     * @experimental
-     * @category MicroExit
-     */
-    type Success<A, E = never> = Either.Right<MicroCause<E>, A>;
-    /**
-     * @since 3.4.6
-     * @experimental
-     * @category MicroExit
-     */
-    type Failure<A, E = never> = Either.Left<MicroCause<E>, A>;
-}
-/**
- * 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.
- *
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export type MicroExit<A, E = never> = MicroExit.Success<A, E> | MicroExit.Failure<A, E>;
+export declare const FiberTypeId: unique symbol;
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitInterrupt: MicroExit<never>;
+export type FiberTypeId = typeof FiberTypeId;
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitSucceed: <A>(a: A) => MicroExit<A, never>;
+export interface Fiber<out A, out E = never> {
+    readonly [FiberTypeId]: Fiber.Variance<A, E>;
+    readonly currentOpCount: number;
+    readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A;
+    readonly context: Context.Context<never>;
+    readonly addObserver: (cb: (exit: MicroExit<A, E>) => void) => () => void;
+    readonly unsafeInterrupt: () => void;
+    readonly unsafePoll: () => MicroExit<A, E> | undefined;
+}
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitFail: <E>(e: E) => MicroExit<never, E>;
+export declare namespace Fiber {
+    /**
+     * @since 3.11.0
+     * @experimental
+     * @category Fiber
+     */
+    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> {
+    context: Context.Context<never>;
+    interruptible: boolean;
+    readonly [FiberTypeId]: Fiber.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;
+    currentOpCount: number;
+    constructor(context: Context.Context<never>, interruptible?: boolean);
+    getRef<I, A>(ref: Context.Reference<I, A>): A;
+    addObserver(cb: (exit: MicroExit<A, E>) => void): () => void;
+    _interrupted: boolean;
+    unsafeInterrupt(): void;
+    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;
+    _yielded: MicroExit<any, any> | (() => void) | undefined;
+    yieldWith(value: MicroExit<any, any> | (() => void)): Yield;
+    children(): Set<Fiber<any, any>>;
+}
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitDie: (defect: unknown) => MicroExit<never>;
+export declare const fiberAwait: <A, E>(self: Fiber<A, E>) => Micro<MicroExit<A, E>>;
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E>;
+export declare const fiberInterrupt: <A, E>(self: Fiber<A, E>) => Micro<void>;
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare const exitIsSuccess: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Success<A, E>;
+export declare const fiberInterruptAll: <A extends Iterable<Fiber<any, any>>>(fibers: A) => Micro<void>;
+declare const identifier: unique symbol;
+type identifier = typeof identifier;
+declare const evaluate: unique symbol;
+type evaluate = typeof evaluate;
+declare const successCont: unique symbol;
+type successCont = typeof successCont;
+declare const failureCont: unique symbol;
+type failureCont = typeof failureCont;
+declare const ensureCont: unique symbol;
+type ensureCont = typeof ensureCont;
+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;
+}
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will succeed with the specified constant value.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export declare const exitIsFailure: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E>;
+export declare const succeed: <A>(value: A) => Micro<A>;
 /**
+ * Creates a `Micro` effect that will fail with the specified `MicroCause`.
+ *
  * @since 3.4.6
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export declare const exitIsInterrupt: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Interrupt, A>;
+export declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>;
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will fail with the specified error.
+ *
+ * This will result in a `CauseFail`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export declare const exitIsFail: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Fail<E>, A>;
+export declare const fail: <E>(error: E) => Micro<never, E>;
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ *
+ * If the evaluation of the value throws an error, the effect will fail with
+ * `CauseDie`.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export declare const exitIsDie: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Die, A>;
+export declare const sync: <A>(evaluate: LazyArg<A>) => Micro<A>;
 /**
- * @since 3.4.6
+ * Lazily creates a `Micro` effect from the given side-effect.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export declare const exitVoid: MicroExit<void>;
+export declare const suspend: <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>) => Micro<A, E, R>;
 /**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * scheduler tick.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const EnvTypeId: unique symbol;
+export declare const yieldNowWith: (priority?: number) => Micro<void>;
 /**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * scheduler tick.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export type EnvTypeId = typeof EnvTypeId;
+export declare const yieldNow: Micro<void>;
 /**
+ * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export interface Env<R> extends Pipeable {
-    readonly [EnvTypeId]: {
-        _R: Covariant<R>;
-    };
-    readonly refs: ReadonlyRecord<string, unknown>;
-}
+export declare const succeedSome: <A>(a: A) => Micro<Option.Option<A>>;
 /**
+ * Creates a `Micro` effect that will succeed with `Option.None`.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const envMake: <R = never>(refs: Record<string, unknown>) => Env<R>;
+export declare const succeedNone: Micro<Option.Option<never>>;
 /**
+ * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const envUnsafeMakeEmpty: () => Env<never>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<MicroCause<E>>) => Micro<never, E>;
 /**
+ * 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.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const envGet: {
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <A>(ref: EnvRef<A>): <R>(self: Env<R>) => A;
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <A, R>(self: Env<R>, ref: EnvRef<A>): A;
-};
+export declare const die: (defect: unknown) => Micro<never>;
 /**
- * @since 3.4.0
+ * 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.
+ *
+ * @since 3.4.6
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const envSet: {
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <A>(ref: EnvRef<A>, value: A): <R>(self: Env<R>) => Env<R>;
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <A, R>(self: Env<R>, ref: EnvRef<A>, value: A): Env<R>;
-};
+export declare const failSync: <E>(error: LazyArg<E>) => Micro<never, E>;
 /**
+ * Converts an `Option` into a `Micro` effect, that will fail with
+ * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the
+ * value of the option.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const envMutate: {
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    (f: (map: Record<string, unknown>) => void): <R>(self: Env<R>) => Env<R>;
-    /**
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <R>(self: Env<R>, f: (map: Record<string, unknown>) => void): Env<R>;
-};
+export declare const fromOption: <A>(option: Option.Option<A>) => Micro<A, NoSuchElementException>;
 /**
- * Access the given `Context.Tag` from the environment.
+ * Converts an `Either` into a `Micro` effect, that will fail with the left side
+ * of the either if it is a `Left`. Otherwise, it will succeed with the right
+ * side of the either.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const service: <I, S>(tag: Context.Tag<I, S>) => Micro<S, never, I>;
+export declare const fromEither: <R, L>(either: Either.Either<R, L>) => Micro<R, L>;
+declare const void_: Micro<void>;
+export { 
 /**
- * Access the given `Context.Tag` from the environment, without tracking the
- * dependency at the type level.
- *
- * It will return an `Option` of the service, depending on whether it is
- * available in the environment or not.
+ * A `Micro` effect that will succeed with `void` (`undefined`).
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Micro<Option.Option<S>>;
+void_ as void };
+declare const try_: <A, E>(options: {
+    try: LazyArg<A>;
+    catch: (error: unknown) => E;
+}) => Micro<A, E>;
+export { 
 /**
- * Retrieve the current value of the given `EnvRef`.
+ * 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 environment
+ * @category constructors
+ * @example
+ * ```ts
+ * import { Micro } from "effect"
+ *
+ * Micro.try({
+ *   try: () => throw new Error("boom"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ * ```
  */
-export declare const getEnvRef: <A>(envRef: EnvRef<A>) => Micro<A>;
+try_ as try };
 /**
- * Set the value of the given `EnvRef` for the duration of the effect.
+ * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
+ * `CauseDie`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const locally: {
-    /**
-     * Set the value of the given `EnvRef` for the duration of the effect.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <A>(fiberRef: EnvRef<A>, value: A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>;
-    /**
-     * Set the value of the given `EnvRef` for the duration of the effect.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category environment
-     */
-    <XA, E, R, A>(self: Micro<XA, E, R>, fiberRef: EnvRef<A>, value: A): Micro<XA, E, R>;
-};
+export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Micro<A>;
 /**
- * Access the current `Context` from the environment.
+ * 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 environment
- */
-export declare const context: <R>() => Micro<Context.Context<R>>;
+ * @category constructors
+ * @example
+ * ```ts
+ * import { Micro } from "effect"
+ *
+ * Micro.tryPromise({
+ *   try: () => Promise.resolve("success"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ * ```
+ */
+export declare const tryPromise: <A, E>(options: {
+    readonly try: (signal: AbortSignal) => PromiseLike<A>;
+    readonly catch: (error: unknown) => E;
+}) => Micro<A, E>;
 /**
- * Merge the given `Context` with the current context.
+ * Create a `Micro` effect using the current `Fiber`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export declare const provideContext: {
+export declare const withFiber: <A, E = never, R = never>(evaluate: (fiber: FiberImpl<A, E>) => Micro<A, E, R>) => Micro<A, E, R>;
+/**
+ * Flush any yielded effects that are waiting to be executed.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const yieldFlush: Micro<void>;
+/**
+ * Create a `Micro` effect from an asynchronous computation.
+ *
+ * You can return a cleanup effect that will be run when the effect is aborted.
+ * It is also passed an `AbortSignal` that is triggered when the effect is
+ * aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const async: <A, E = never, R = never>(register: (resume: (effect: Micro<A, E, R>) => void, signal: AbortSignal) => void | Micro<void, never, R>) => Micro<A, E, R>;
+/**
+ * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
+ * the Javascript runtime from exiting.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const never: Micro<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const gen: <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(...args: [self: Self, body: (this: Self) => Generator<Eff, AEff, never>] | [body: () => Generator<Eff, AEff, never>]) => Micro<AEff, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never>;
+/**
+ * Create a `Micro` effect that will replace the success value of the given
+ * effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const as: {
     /**
-     * Merge the given `Context` with the current context.
+     * Create a `Micro` effect that will replace the success value of the given
+     * effect.
      *
      * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>;
+    <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
     /**
-     * Merge the given `Context` with the current context.
+     * Create a `Micro` effect that will replace the success value of the given
+     * effect.
      *
      * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>;
+    <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>;
 };
 /**
- * Add the provided service to the current context.
+ * Wrap the success value of this `Micro` effect in an `Option.Some`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export declare const provideService: {
+export declare const asSome: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
+/**
+ * Swap the error and success types of the `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+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.
+ *
+ * It also allows you to pass in a `Micro` effect directly, which will be
+ * executed after the current effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const andThen: {
     /**
-     * Add the provided service to the current context.
+     * 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.
      *
      * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>;
+    <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>;
     /**
-     * Add the provided service to the current context.
+     * 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.
      *
      * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>;
-};
-/**
- * Create a service using the provided `Micro` effect, and add it to the
- * current context.
- *
- * @since 3.4.6
- * @experimental
- * @category environment
- */
-export declare const provideServiceEffect: {
+    <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>;
     /**
-     * Create a service using the provided `Micro` effect, and add it to the
-     * current context.
+     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+     * a single api.
      *
-     * @since 3.4.6
+     * It also allows you to pass in a `Micro` effect directly, which will be
+     * executed after the current effect.
+     *
+     * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <I, S, E2, R2>(tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>;
+    <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>;
     /**
-     * Create a service using the provided `Micro` effect, and add it to the
-     * current context.
+     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+     * a single api.
      *
-     * @since 3.4.6
+     * It also allows you to pass in a `Micro` effect directly, which will be
+     * executed after the current effect.
+     *
+     * @since 3.4.0
      * @experimental
-     * @category environment
+     * @category mapping & sequencing
      */
-    <A, E, R, I, S, E2, R2>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): Micro<A, E | E2, Exclude<R, I> | R2>;
+    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
 };
 /**
- * @since 3.5.9
- * @experimental
- * @category scheduler
- */
-export interface MicroScheduler {
-    readonly scheduleTask: (task: () => void, priority: number) => void;
-    readonly shouldYield: (env: Env<unknown>) => boolean;
-    readonly flush: () => void;
-}
-/**
- * @since 3.5.9
+ * Execute a side effect from the success value of the `Micro` effect.
+ *
+ * It is similar to the `andThen` api, but the success value is ignored.
+ *
+ * @since 3.4.0
  * @experimental
- * @category scheduler
+ * @category mapping & sequencing
  */
-export declare class MicroSchedulerDefault implements MicroScheduler {
-    private tasks;
-    private running;
-    /**
-     * @since 3.5.9
-     */
-    scheduleTask(task: () => void, _priority: number): void;
+export declare const tap: {
     /**
-     * @since 3.5.9
+     * Execute a side effect from the success value of the `Micro` effect.
+     *
+     * It is similar to the `andThen` api, but the success value is ignored.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
      */
-    afterScheduled: () => void;
+    <A, X>(f: (a: NoInfer<A>) => X): <E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
     /**
-     * @since 3.5.9
+     * Execute a side effect from the success value of the `Micro` effect.
+     *
+     * It is similar to the `andThen` api, but the success value is ignored.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
      */
-    runTasks(): void;
+    <X>(f: NotFunction<X>): <A, E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
     /**
-     * @since 3.5.9
+     * Execute a side effect from the success value of the `Micro` effect.
+     *
+     * It is similar to the `andThen` api, but the success value is ignored.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
      */
-    shouldYield(_env: Env<unknown>): boolean;
+    <A, E, R, X>(self: Micro<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
     /**
-     * @since 3.5.9
+     * Execute a side effect from the success value of the `Micro` effect.
+     *
+     * It is similar to the `andThen` api, but the success value is ignored.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
      */
-    flush(): void;
-}
+    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+};
 /**
+ * Replace the success value of the `Micro` effect with `void`.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export declare const EnvRefTypeId: unique symbol;
+export declare const asVoid: <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>;
 /**
- * @since 3.4.0
+ * Access the `MicroExit` of the given `Micro` effect.
+ *
+ * @since 3.4.6
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export type EnvRefTypeId = typeof EnvRefTypeId;
+export declare const exit: <A, E, R>(self: Micro<A, E, R>) => Micro<MicroExit<A, E>, never, R>;
 /**
+ * Replace the error type of the given `Micro` with the full `MicroCause` object.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export interface EnvRef<A> extends Micro<A> {
-    readonly [EnvRefTypeId]: EnvRefTypeId;
-    readonly key: string;
-    readonly initial: A;
-    [Unify.typeSymbol]?: unknown;
-    [Unify.unifySymbol]?: EnvRefUnify<this>;
-    [Unify.ignoreSymbol]?: EnvRefUnifyIgnore;
-}
+export declare const sandbox: <A, E, R>(self: Micro<A, E, R>) => Micro<A, MicroCause<E>, R>;
 /**
- * @category models
- * @since 3.8.4
+ * Returns an effect that races all the specified effects,
+ * yielding the value of the first effect to succeed with a value. Losers of
+ * the race will be interrupted immediately
+ *
+ * @since 3.4.0
  * @experimental
+ * @category sequencing
  */
-export interface EnvRefUnify<A extends {
-    [Unify.typeSymbol]?: any;
-}> extends MicroUnify<A> {
-    EnvRef?: () => A[Unify.typeSymbol] extends EnvRef<infer A0> | infer _ ? EnvRef<A0> : never;
-}
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface EnvRefUnifyIgnore extends MicroUnifyIgnore {
-    Micro?: true;
-}
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const envRefMake: <A>(key: string, initial: LazyArg<A>) => EnvRef<A>;
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const currentAbortController: EnvRef<AbortController>;
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const currentAbortSignal: EnvRef<AbortSignal>;
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const currentContext: EnvRef<Context.Context<never>>;
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const currentConcurrency: EnvRef<"unbounded" | number>;
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export declare const currentMaxDepthBeforeYield: EnvRef<number>;
+export declare const raceAll: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
 /**
+ * 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
+ *
  * @since 3.4.0
  * @experimental
- * @category environment refs
+ * @category sequencing
  */
-export declare const currentScheduler: EnvRef<MicroScheduler>;
+export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
 /**
- * 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.
+ * Returns an effect that races two effects, yielding the value of the first
+ * effect to succeed. Losers of the race will be interrupted immediately
  *
  * @since 3.4.0
  * @experimental
- * @category environment refs
- * @example
- * import * as Micro from "effect/Micro"
- *
- * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
- *   concurrency: "inherit"
- * }).pipe(
- *   Micro.withConcurrency(2) // use a concurrency of 2
- * )
+ * @category sequencing
  */
-export declare const withConcurrency: {
+export declare const race: {
     /**
-     * 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.
+     * Returns an effect that races two effects, yielding the value of the first
+     * effect to succeed. Losers of the race will be interrupted immediately
      *
      * @since 3.4.0
      * @experimental
-     * @category environment refs
-     * @example
-     * import * as Micro from "effect/Micro"
-     *
-     * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
-     *   concurrency: "inherit"
-     * }).pipe(
-     *   Micro.withConcurrency(2) // use a concurrency of 2
-     * )
+     * @category sequencing
      */
-    (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
     /**
-     * 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.
+     * Returns an effect that races two effects, yielding the value of the first
+     * effect to succeed. Losers of the race will be interrupted immediately
      *
      * @since 3.4.0
      * @experimental
-     * @category environment refs
-     * @example
-     * import * as Micro from "effect/Micro"
-     *
-     * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
-     *   concurrency: "inherit"
-     * }).pipe(
-     *   Micro.withConcurrency(2) // use a concurrency of 2
-     * )
+     * @category sequencing
      */
-    <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>;
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
 };
 /**
- * A low-level constructor for creating a `Micro` effect. It takes a function
- * that receives an environment and a callback which should be called with the
- * result of the effect.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export declare const make: <R, A, E>(run: (env: Env<R>, onExit: (exit: MicroExit<A, E>) => void) => void) => Micro<A, E, R>;
-/**
- * Converts a `MicroExit` into a `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category constructors
- */
-export declare const fromExit: <A, E>(self: MicroExit<A, E>) => Micro<A, E>;
-/**
- * Converts a lazy `MicroExit` into a `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category constructors
- */
-export declare const fromExitSync: <A, E>(self: LazyArg<MicroExit<A, E>>) => Micro<A, E>;
-/**
- * Creates a `Micro` effect that will succeed with the specified constant value.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export declare const succeed: <A>(a: A) => Micro<A>;
-/**
- * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ * 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
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category sequencing
  */
-export declare const succeedSome: <A>(a: A) => Micro<Option.Option<A>>;
+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
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category sequencing
+     */
+    <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
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category sequencing
+     */
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
+};
 /**
- * Creates a `Micro` effect that will succeed with `Option.None`.
+ * Map the success value of this `Micro` effect to another `Micro` effect, then
+ * flatten the result.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export declare const succeedNone: Micro<Option.Option<never>>;
+export declare const flatMap: {
+    /**
+     * Map the success value of this `Micro` effect to another `Micro` effect, then
+     * flatten the result.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
+    <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>;
+    /**
+     * Map the success value of this `Micro` effect to another `Micro` effect, then
+     * flatten the result.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>;
+};
 /**
- * Creates a `Micro` effect that will fail with the specified error.
- *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * Flattens any nested `Micro` effects, merging the error and requirement types.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export declare const fail: <E>(e: E) => Micro<never, E>;
+export declare const flatten: <A, E, R, E2, R2>(self: Micro<Micro<A, E, R>, E2, R2>) => Micro<A, E | E2, R | R2>;
 /**
- * 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.
+ * Transforms the success value of the `Micro` effect with the specified
+ * function.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export declare const failSync: <E>(e: LazyArg<E>) => Micro<never, E>;
+export declare const map: {
+    /**
+     * Transforms the success value of the `Micro` effect with the specified
+     * function.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
+    <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    /**
+     * Transforms the success value of the `Micro` effect with the specified
+     * function.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
+    <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>;
+};
 /**
- * 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.
+ * The MicroExit type is a data type that represents the result of a Micro
+ * computation.
  *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export declare const die: (defect: unknown) => Micro<never>;
-/**
- * Creates a `Micro` effect that will fail with the specified `MicroCause`.
+ * It uses the `Either` data type to represent the success and failure cases.
  *
  * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>;
+export type MicroExit<A, E = never> = MicroExit.Success<A, E> | MicroExit.Failure<A, E>;
 /**
- * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`.
- *
  * @since 3.4.6
  * @experimental
- * @category constructors
- */
-export declare const failCauseSync: <E>(cause: LazyArg<MicroCause<E>>) => Micro<never, E>;
-/**
- * Creates a `Micro` effect that will succeed with the lazily evaluated value.
- *
- * If the evaluation of the value throws an error, the effect will fail with
- * `CauseDie`.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const sync: <A>(evaluate: LazyArg<A>) => Micro<A>;
+export declare namespace MicroExit {
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category MicroExit
+     */
+    interface Proto<out A, out E = never> extends Micro<A, E> {
+        readonly [MicroExitTypeId]: MicroExitTypeId;
+    }
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category MicroExit
+     */
+    interface Success<out A, out E> extends Proto<A, E> {
+        readonly _tag: "Success";
+        readonly value: A;
+    }
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category MicroExit
+     */
+    interface Failure<out A, out E> extends Proto<A, E> {
+        readonly _tag: "Failure";
+        readonly cause: MicroCause<E>;
+    }
+}
 /**
- * Converts an `Option` into a `Micro` effect, that will fail with
- * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the
- * value of the option.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const fromOption: <A>(option: Option.Option<A>) => Micro<A, NoSuchElementException>;
+export declare const isMicroExit: (u: unknown) => u is MicroExit<unknown, unknown>;
 /**
- * Converts an `Either` into a `Micro` effect, that will fail with the left side
- * of the either if it is a `Left`. Otherwise, it will succeed with the right
- * side of the either.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const fromEither: <R, L>(either: Either.Either<R, L>) => Micro<R, L>;
+export declare const exitSucceed: <A>(a: A) => MicroExit<A, never>;
 /**
- * Lazily creates a `Micro` effect from the given side-effect.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const suspend: <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>) => Micro<A, E, R>;
-declare const void_: Micro<void>;
-export { 
+export declare const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E>;
 /**
- * A `Micro` effect that will succeed with `void` (`undefined`).
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-void_ as void };
+export declare const exitInterrupt: MicroExit<never>;
 /**
- * Create a `Micro` effect from an asynchronous computation.
- *
- * You can return a cleanup effect that will be run when the effect is aborted.
- * It is also passed an `AbortSignal` that is triggered when the effect is
- * aborted.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const async: <A, E = never, R = never>(register: (resume: (effect: Micro<A, E, R>) => void, signal: AbortSignal) => void | Micro<void, never, R>) => Micro<A, E, R>;
-declare const try_: <A, E>(options: {
-    try: LazyArg<A>;
-    catch: (error: unknown) => E;
-}) => Micro<A, E>;
-export { 
+export declare const exitFail: <E>(e: E) => MicroExit<never, E>;
 /**
- * The `Micro` equivalent of a try / catch block, which allows you to map
- * thrown errors to a specific error type.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
- * @example
- * import { Micro } from "effect"
- *
- * Micro.try({
- *   try: () => throw new Error("boom"),
- *   catch: (cause) => new Error("caught", { cause })
- * })
+ * @category MicroExit
  */
-try_ as try };
+export declare const exitDie: (defect: unknown) => MicroExit<never>;
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
- * `CauseDie`.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Micro<A>;
+export declare const exitIsSuccess: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Success<A, E>;
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
- * converted into a specific error type.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
- * @example
- * import { Micro } from "effect"
- *
- * Micro.tryPromise({
- *   try: () => Promise.resolve("success"),
- *   catch: (cause) => new Error("caught", { cause })
- * })
+ * @category MicroExit
  */
-export declare const tryPromise: <A, E>(options: {
-    readonly try: (signal: AbortSignal) => PromiseLike<A>;
-    readonly catch: (error: unknown) => E;
-}) => Micro<A, E>;
+export declare const exitIsFailure: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E>;
 /**
- * Pause the execution of the current `Micro` effect, and resume it on the next
- * iteration of the event loop.
- *
- * You can specify a priority for the task, which will determine when it is
- * executed relative to other tasks.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const yieldWithPriority: (priority: number) => Micro<void>;
+export declare const exitIsInterrupt: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E> & {
+    readonly cause: MicroCause.Interrupt;
+};
 /**
- * Pause the execution of the current `Micro` effect, and resume it on the next
- * iteration of the event loop.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const yieldNow: Micro<void>;
+export declare const exitIsFail: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E> & {
+    readonly cause: MicroCause.Fail<E>;
+};
 /**
- * Flush any yielded effects that are waiting to be executed.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const yieldFlush: Micro<void>;
-/**
- * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
- * the Javascript runtime from exiting.
- *
- * @since 3.4.0
+export declare const exitIsDie: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E> & {
+    readonly cause: MicroCause.Die;
+};
+/**
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const never: Micro<never>;
+export declare const exitVoid: MicroExit<void>;
 /**
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export declare const gen: <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(...args: [self: Self, body: (this: Self) => Generator<Eff, AEff, never>] | [body: () => Generator<Eff, AEff, never>]) => Micro<AEff, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never>;
+export declare const exitVoidAll: <I extends Iterable<MicroExit<any, any>>>(exits: I) => MicroExit<void, I extends Iterable<MicroExit<infer _A, infer _E>> ? _E : never>;
 /**
- * Flattens any nested `Micro` effects, merging the error and requirement types.
- *
- * @since 3.4.0
+ * @since 3.5.9
  * @experimental
- * @category mapping & sequencing
+ * @category scheduler
  */
-export declare const flatten: <A, E, R, E2, R2>(self: Micro<Micro<A, E, R>, E2, R2>) => Micro<A, E | E2, R | R2>;
+export interface MicroScheduler {
+    readonly scheduleTask: (task: () => void, priority: number) => void;
+    readonly shouldYield: (fiber: Fiber<unknown, unknown>) => boolean;
+    readonly flush: () => void;
+}
 /**
- * Transforms the success value of the `Micro` effect with the specified
- * function.
- *
- * @since 3.4.0
+ * @since 3.5.9
  * @experimental
- * @category mapping & sequencing
+ * @category scheduler
  */
-export declare const map: {
+export declare class MicroSchedulerDefault implements MicroScheduler {
+    private tasks;
+    private running;
     /**
-     * Transforms the success value of the `Micro` effect with the specified
-     * function.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category mapping & sequencing
+     * @since 3.5.9
      */
-    <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    scheduleTask(task: () => void, _priority: number): void;
     /**
-     * Transforms the success value of the `Micro` effect with the specified
-     * function.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category mapping & sequencing
+     * @since 3.5.9
      */
-    <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>;
-};
+    afterScheduled: () => void;
+    /**
+     * @since 3.5.9
+     */
+    runTasks(): void;
+    /**
+     * @since 3.5.9
+     */
+    shouldYield(fiber: Fiber<unknown, unknown>): boolean;
+    /**
+     * @since 3.5.9
+     */
+    flush(): void;
+}
 /**
- * Create a `Micro` effect that will replace the success value of the given
- * effect.
+ * Access the given `Context.Tag` from the environment.
  *
  * @since 3.4.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export declare const as: {
+export declare const service: {
     /**
-     * Create a `Micro` effect that will replace the success value of the given
-     * effect.
+     * Access the given `Context.Tag` from the environment.
      *
      * @since 3.4.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    <I, S>(tag: Context.Reference<I, S>): Micro<S>;
     /**
-     * Create a `Micro` effect that will replace the success value of the given
-     * effect.
+     * Access the given `Context.Tag` from the environment.
      *
      * @since 3.4.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>;
+    <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I>;
 };
 /**
- * Wrap the success value of this `Micro` effect in an `Option.Some`.
+ * Access the given `Context.Tag` from the environment, without tracking the
+ * dependency at the type level.
+ *
+ * It will return an `Option` of the service, depending on whether it is
+ * available in the environment or not.
  *
  * @since 3.4.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export declare const asSome: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
+export declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Micro<Option.Option<S>>;
 /**
- * Map the success value of this `Micro` effect to another `Micro` effect, then
- * flatten the result.
+ * Update the Context with the given mapping function.
  *
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export declare const flatMap: {
+export declare const updateContext: {
     /**
-     * Map the success value of this `Micro` effect to another `Micro` effect, then
-     * flatten the result.
+     * Update the Context with the given mapping function.
      *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>;
+    <R2, R>(f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>;
     /**
-     * Map the success value of this `Micro` effect to another `Micro` effect, then
-     * flatten the result.
+     * Update the Context with the given mapping function.
      *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>;
+    <A, E, R, R2>(self: Micro<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): Micro<A, E, R2>;
 };
 /**
- * Swap the error and success types of the `Micro` effect.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-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.
- *
- * It also allows you to pass in a `Micro` effect directly, which will be
- * executed after the current effect.
+ * Update the service for the given `Context.Tag` in the environment.
  *
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export declare const andThen: {
+export declare const updateService: {
     /**
-     * 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.
+     * Update the service for the given `Context.Tag` in the environment.
      *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <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>;
+    <I, A>(tag: Context.Reference<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>;
     /**
-     * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-     * a single api.
+     * Update the service for the given `Context.Tag` in the environment.
      *
-     * It also allows you to pass in a `Micro` effect directly, which will be
-     * executed after the current effect.
-     *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <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>;
+    <I, A>(tag: Context.Tag<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R | I>;
     /**
-     * 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.
+     * Update the service for the given `Context.Tag` in the environment.
      *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <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>;
+    <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Reference<I, A>, f: (value: A) => A): Micro<XA, E, R>;
     /**
-     * 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.
+     * Update the service for the given `Context.Tag` in the environment.
      *
-     * @since 3.4.0
+     * @since 3.11.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
+    <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Tag<I, A>, f: (value: A) => A): Micro<XA, E, R | I>;
 };
 /**
- * Execute a side effect from the success value of the `Micro` effect.
+ * Access the current `Context` from the environment.
  *
- * It is similar to the `andThen` api, but the success value is ignored.
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const context: <R>() => Micro<Context.Context<R>>;
+/**
+ * Merge the given `Context` with the current context.
  *
  * @since 3.4.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export declare const tap: {
-    /**
-     * Execute a side effect from the success value of the `Micro` effect.
-     *
-     * It is similar to the `andThen` api, but the success value is ignored.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category mapping & sequencing
-     */
-    <A, X>(f: (a: NoInfer<A>) => X): <E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
-    /**
-     * Execute a side effect from the success value of the `Micro` effect.
-     *
-     * It is similar to the `andThen` api, but the success value is ignored.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category mapping & sequencing
-     */
-    <X>(f: NotFunction<X>): <A, E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+export declare const provideContext: {
     /**
-     * Execute a side effect from the success value of the `Micro` effect.
-     *
-     * It is similar to the `andThen` api, but the success value is ignored.
+     * Merge the given `Context` with the current context.
      *
      * @since 3.4.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, E, R, X>(self: Micro<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+    <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>;
     /**
-     * Execute a side effect from the success value of the `Micro` effect.
-     *
-     * It is similar to the `andThen` api, but the success value is ignored.
+     * Merge the given `Context` with the current context.
      *
      * @since 3.4.0
      * @experimental
-     * @category mapping & sequencing
+     * @category environment
      */
-    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+    <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>;
 };
 /**
- * Replace the success value of the `Micro` effect with `void`.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export declare const asVoid: <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>;
-/**
- * Access the `MicroExit` of the given `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category mapping & sequencing
- */
-export declare const exit: <A, E, R>(self: Micro<A, E, R>) => Micro<MicroExit<A, E>, never, R>;
-/**
- * Replace the error type of the given `Micro` with the full `MicroCause` object.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export declare const sandbox: <A, E, R>(self: Micro<A, E, R>) => Micro<A, MicroCause<E>, R>;
-/**
- * Returns an effect that races all the specified effects,
- * yielding the value of the first effect to succeed with a value. Losers of
- * the race will be interrupted immediately
- *
- * @since 3.4.0
- * @experimental
- * @category sequencing
- */
-export declare const raceAll: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
-/**
- * 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
+ * Add the provided service to the current context.
  *
  * @since 3.4.0
  * @experimental
- * @category sequencing
+ * @category environment
  */
-export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
+export declare const provideService: {
+    /**
+     * Add the provided service to the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
+    <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>;
+    /**
+     * Add the provided service to the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
+    <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>;
+};
 /**
- * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed. Losers of the race will be interrupted immediately
+ * Create a service using the provided `Micro` effect, and add it to the
+ * current context.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category sequencing
+ * @category environment
  */
-export declare const race: {
+export declare const provideServiceEffect: {
     /**
-     * Returns an effect that races two effects, yielding the value of the first
-     * effect to succeed. Losers of the race will be interrupted immediately
+     * Create a service using the provided `Micro` effect, and add it to the
+     * current context.
      *
-     * @since 3.4.0
+     * @since 3.4.6
      * @experimental
-     * @category sequencing
+     * @category environment
      */
-    <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    <I, S, E2, R2>(tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | 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
+     * Create a service using the provided `Micro` effect, and add it to the
+     * current context.
      *
-     * @since 3.4.0
+     * @since 3.4.6
      * @experimental
-     * @category sequencing
+     * @category environment
      */
-    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
+    <A, E, R, I, S, E2, R2>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): Micro<A, E | E2, Exclude<R, I> | R2>;
 };
+declare const MaxOpsBeforeYield_base: Context.ReferenceClass<MaxOpsBeforeYield, "effect/Micro/currentMaxOpsBeforeYield", number>;
 /**
- * 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
+ * @since 3.11.0
+ * @experimental
+ * @category references
+ */
+export declare class MaxOpsBeforeYield extends MaxOpsBeforeYield_base {
+}
+declare const CurrentConcurrency_base: Context.ReferenceClass<CurrentConcurrency, "effect/Micro/currentConcurrency", number | "unbounded">;
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category environment refs
+ */
+export declare class CurrentConcurrency extends CurrentConcurrency_base {
+}
+declare const CurrentScheduler_base: Context.ReferenceClass<CurrentScheduler, "effect/Micro/currentScheduler", MicroScheduler>;
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category environment refs
+ */
+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 sequencing
+ * @category environment refs
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+ *   concurrency: "inherit"
+ * }).pipe(
+ *   Micro.withConcurrency(2) // use a concurrency of 2
+ * )
  */
-export declare const raceFirst: {
+export declare const withConcurrency: {
     /**
-     * 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
+     * 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 sequencing
+     * @category environment refs
+     * @example
+     * import * as Micro from "effect/Micro"
+     *
+     * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+     *   concurrency: "inherit"
+     * }).pipe(
+     *   Micro.withConcurrency(2) // use a concurrency of 2
+     * )
      */
-    <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
     /**
-     * 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
+     * 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 sequencing
+     * @category environment refs
+     * @example
+     * import * as Micro from "effect/Micro"
+     *
+     * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+     *   concurrency: "inherit"
+     * }).pipe(
+     *   Micro.withConcurrency(2) // use a concurrency of 2
+     * )
      */
-    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
+    <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>;
 };
 /**
  * Combine two `Micro` effects into a single effect that produces a tuple of
@@ -1653,6 +1633,84 @@ export declare const repeat: {
         schedule?: MicroSchedule | undefined;
     } | undefined): Micro<A, E, R>;
 };
+/**
+ * Replicates the given effect `n` times.
+ *
+ * @since 3.11.0
+ * @experimental
+ * @category repetition
+ */
+export declare const replicate: {
+    /**
+     * Replicates the given effect `n` times.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category repetition
+     */
+    (n: number): <A, E, R>(self: Micro<A, E, R>) => Array<Micro<A, E, R>>;
+    /**
+     * Replicates the given effect `n` times.
+     *
+     * @since 3.11.0
+     * @experimental
+     * @category repetition
+     */
+    <A, E, R>(self: Micro<A, E, R>, n: number): Array<Micro<A, E, R>>;
+};
+/**
+ * Performs this effect the specified number of times and collects the
+ * results.
+ *
+ * @since 3.11.0
+ * @category repetition
+ */
+export declare const replicateEffect: {
+    /**
+     * Performs this effect the specified number of times and collects the
+     * results.
+     *
+     * @since 3.11.0
+     * @category repetition
+     */
+    (n: number, options?: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard?: false | undefined;
+    }): <A, E, R>(self: Micro<A, E, R>) => Micro<Array<A>, E, R>;
+    /**
+     * Performs this effect the specified number of times and collects the
+     * results.
+     *
+     * @since 3.11.0
+     * @category repetition
+     */
+    (n: number, options: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard: true;
+    }): <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>;
+    /**
+     * Performs this effect the specified number of times and collects the
+     * results.
+     *
+     * @since 3.11.0
+     * @category repetition
+     */
+    <A, E, R>(self: Micro<A, E, R>, n: number, options?: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard?: false | undefined;
+    }): Micro<Array<A>, E, R>;
+    /**
+     * Performs this effect the specified number of times and collects the
+     * results.
+     *
+     * @since 3.11.0
+     * @category repetition
+     */
+    <A, E, R>(self: Micro<A, E, R>, n: number, options: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard: true;
+    }): Micro<void, E, R>;
+};
 /**
  * Repeat the given `Micro` effect forever, only stopping if the effect fails.
  *
@@ -2741,6 +2799,31 @@ export declare const onExit: {
      */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
+/**
+ * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const ensuring: {
+    /**
+     * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
+    <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    /**
+     * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
 /**
  * When the `Micro` effect is completed, run the given finalizer effect if it
  * matches the specified predicate.
@@ -2787,31 +2870,6 @@ export declare const onExitIf: {
      */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>, f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
-/**
- * Regardless of the result of the this `Micro` effect, run the finalizer effect.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export declare const ensuring: {
-    /**
-     * Regardless of the result of the this `Micro` effect, run the finalizer effect.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category resources & finalization
-     */
-    <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
-    /**
-     * Regardless of the result of the this `Micro` effect, run the finalizer effect.
-     *
-     * @since 3.4.0
-     * @experimental
-     * @category resources & finalization
-     */
-    <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
-};
 /**
  * When the `Micro` effect fails, run the given finalizer effect with the
  * `MicroCause` of the executed effect.
@@ -2883,14 +2941,23 @@ export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acqu
  */
 export declare const interrupt: Micro<never>;
 /**
- * Wrap the given `Micro` effect in an uninterruptible region, preventing the
- * effect from being aborted.
+ * Flag the effect as uninterruptible, which means that when the effect is
+ * interrupted, it will be allowed to continue running until completion.
  *
  * @since 3.4.0
  * @experimental
- * @category interruption
+ * @category flags
  */
 export declare const uninterruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+/**
+ * Flag the effect as interruptible, which means that when the effect is
+ * interrupted, it will be interrupted immediately.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category flags
+ */
+export declare const interruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
 /**
  * Wrap the given `Micro` effect in an uninterruptible region, preventing the
  * effect from being aborted.
@@ -2902,6 +2969,7 @@ export declare const uninterruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A
  * @experimental
  * @category interruption
  * @example
+ * ```ts
  * import * as Micro from "effect/Micro"
  *
  * Micro.uninterruptibleMask((restore) =>
@@ -2909,17 +2977,9 @@ export declare const uninterruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A
  *     Micro.andThen(restore(Micro.sleep(1000))) // interruptible
  *   )
  * )
+ * ```
  */
 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>;
-/**
- * Wrap the given `Micro` effect in an interruptible region, allowing the effect
- * to be aborted.
- *
- * @since 3.4.0
- * @experimental
- * @category interruption
- */
-export declare const interruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
 /**
  * @since 3.4.0
  * @experimental
@@ -2982,6 +3042,16 @@ export declare const all: <const Arg extends Iterable<Micro<any, any, any>> | Re
     readonly concurrency?: Concurrency | undefined;
     readonly discard?: boolean | undefined;
 }>(arg: Arg, options?: O) => All.Return<Arg, O>;
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category collecting & elements
+ */
+export declare const whileLoop: <A, E, R>(options: {
+    readonly while: LazyArg<boolean>;
+    readonly body: LazyArg<Micro<A, E, R>>;
+    readonly step: (a: A) => void;
+}) => Micro<void, E, R>;
 /**
  * For each element of the provided iterable, run the effect and collect the results.
  *
@@ -3139,60 +3209,6 @@ export {
  * @category do notation
  */
 let_ as let };
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export declare const HandleTypeId: unique symbol;
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export type HandleTypeId = typeof HandleTypeId;
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export interface Handle<A, E = never> extends Micro<A, E> {
-    readonly [HandleTypeId]: HandleTypeId;
-    readonly await: Micro<MicroExit<A, E>>;
-    readonly join: Micro<A, E>;
-    readonly interrupt: Micro<MicroExit<A, E>>;
-    readonly unsafeInterrupt: () => void;
-    readonly addObserver: (observer: (exit: MicroExit<A, E>) => void) => void;
-    readonly removeObserver: (observer: (exit: MicroExit<A, E>) => void) => void;
-    readonly unsafePoll: () => MicroExit<A, E> | null;
-    [Unify.typeSymbol]?: unknown;
-    [Unify.unifySymbol]?: HandleUnify<this>;
-    [Unify.ignoreSymbol]?: HandleUnifyIgnore;
-}
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface HandleUnify<A extends {
-    [Unify.typeSymbol]?: any;
-}> extends MicroUnify<A> {
-    Handle?: () => A[Unify.typeSymbol] extends Handle<infer A0, infer E0> | infer _ ? Handle<A0, E0> : never;
-}
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface HandleUnifyIgnore extends MicroUnifyIgnore {
-    Micro?: true;
-}
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export declare const isHandle: (u: unknown) => u is Handle<unknown, unknown>;
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -3203,7 +3219,7 @@ export declare const isHandle: (u: unknown) => u is Handle<unknown, unknown>;
  * @experimental
  * @category handle & forking
  */
-export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -3214,7 +3230,7 @@ export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>
  * @experimental
  * @category handle & forking
  */
-export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -3236,7 +3252,7 @@ export declare const forkIn: {
      * @experimental
      * @category handle & forking
      */
-    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>;
     /**
      * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
      * aborted.
@@ -3247,7 +3263,7 @@ export declare const forkIn: {
      * @experimental
      * @category handle & forking
      */
-    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Handle<A, E>, never, R>;
+    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R>;
 };
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
@@ -3259,7 +3275,7 @@ export declare const forkIn: {
  * @experimental
  * @category handle & forking
  */
-export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R | MicroScope>;
+export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R | MicroScope>;
 /**
  * Execute the `Micro` effect and return a `Handle` that can be awaited, joined,
  * or aborted.
@@ -3271,6 +3287,7 @@ export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle
  * @experimental
  * @category execution
  * @example
+ * ```ts
  * import * as Micro from "effect/Micro"
  *
  * const handle = Micro.succeed(42).pipe(
@@ -3281,11 +3298,12 @@ export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle
  * handle.addObserver((exit) => {
  *   console.log(exit)
  * })
+ * ```
  */
 export declare const runFork: <A, E>(effect: Micro<A, E>, options?: {
     readonly signal?: AbortSignal | undefined;
     readonly scheduler?: MicroScheduler | undefined;
-} | undefined) => Handle<A, E>;
+} | undefined) => FiberImpl<A, E>;
 /**
  * Execute the `Micro` effect and return a `Promise` that resolves with the
  * `MicroExit` of the computation.
@@ -3336,12 +3354,11 @@ export declare const runSync: <A, E>(effect: Micro<A, E>) => A;
  * @category errors
  */
 export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
-    readonly [EffectTypeId]: Effect.VarianceStruct<never, this, never>;
-    readonly [StreamTypeId]: Stream.VarianceStruct<never, this, never>;
-    readonly [SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>;
-    readonly [ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>;
+    readonly [Effectable.EffectTypeId]: Effect.VarianceStruct<never, this, never>;
+    readonly [Effectable.StreamTypeId]: Stream.VarianceStruct<never, this, never>;
+    readonly [Effectable.SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>;
+    readonly [Effectable.ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>;
     readonly [TypeId]: Micro.Variance<never, this, never>;
-    readonly [runSymbol]: (env: Env<any>, onExit: (exit: MicroExit<never, this>) => void) => void;
     [Symbol.iterator](): MicroIterator<Micro<never, this, never>>;
 }
 /**