effect 3.4.5 → 3.4.7

package/dist/dts/Micro.d.ts

@@ -53,7 +53,7 @@ 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>;
-    readonly [runSymbol]: (env: Env<any>, onResult: (result: Result<A, E>) => void) => void;
+    readonly [runSymbol]: (env: Env<any>, onExit: (exit: MicroExit<A, E>) => void) => void;
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: MicroUnify<this>;
     [Unify.ignoreSymbol]?: MicroUnifyIgnore;
@@ -127,194 +127,218 @@ export interface MicroIterator<T extends Micro<any, any, any>> {
     next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>;
 }
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const FailureTypeId: unique symbol;
+export declare const MicroCauseTypeId: unique symbol;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export type FailureTypeId = typeof FailureTypeId;
+export type MicroCauseTypeId = typeof MicroCauseTypeId;
 /**
- * A Micro Failure is a data type that represents the different ways a Micro can fail.
+ * A Micro Cause is a data type that represents the different ways a Micro can fail.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export type Failure<E> = Failure.Unexpected | Failure.Expected<E> | Failure.Aborted;
+export type MicroCause<E> = MicroCause.Die | MicroCause.Fail<E> | MicroCause.Interrupt;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare namespace Failure {
+export declare namespace MicroCause {
+    /**
+     * @since 3.4.6
+     * @experimental
+     */
+    type Error<T> = T extends MicroCause.Fail<infer E> ? E : never;
     /**
      * @since 3.4.0
      * @experimental
      */
     interface Proto<Tag extends string, E> extends Pipeable, globalThis.Error {
-        readonly [FailureTypeId]: {
+        readonly [MicroCauseTypeId]: {
             _E: Covariant<E>;
         };
         readonly _tag: Tag;
         readonly traces: ReadonlyArray<string>;
     }
     /**
-     * @since 3.4.0
+     * @since 3.4.6
      * @experimental
-     * @category failure
+     * @category MicroCause
      */
-    interface Unexpected extends Proto<"Unexpected", never> {
+    interface Die extends Proto<"Die", never> {
         readonly defect: unknown;
     }
     /**
-     * @since 3.4.0
+     * @since 3.4.6
      * @experimental
-     * @category failure
+     * @category MicroCause
      */
-    interface Expected<E> extends Proto<"Expected", E> {
+    interface Fail<E> extends Proto<"Fail", E> {
         readonly error: E;
     }
     /**
-     * @since 3.4.0
+     * @since 3.4.6
      * @experimental
-     * @category failure
+     * @category MicroCause
      */
-    interface Aborted extends Proto<"Aborted", never> {
+    interface Interrupt extends Proto<"Interrupt", never> {
     }
 }
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const FailureExpected: <E>(error: E, traces?: ReadonlyArray<string>) => Failure<E>;
+export declare const causeFail: <E>(error: E, traces?: ReadonlyArray<string>) => MicroCause<E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const FailureUnexpected: (defect: unknown, traces?: ReadonlyArray<string>) => Failure<never>;
+export declare const causeDie: (defect: unknown, traces?: ReadonlyArray<string>) => MicroCause<never>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const FailureAborted: (traces?: ReadonlyArray<string>) => Failure<never>;
+export declare const causeInterrupt: (traces?: ReadonlyArray<string>) => MicroCause<never>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const failureIsExpected: <E>(self: Failure<E>) => self is Failure.Expected<E>;
+export declare const causeIsFail: <E>(self: MicroCause<E>) => self is MicroCause.Fail<E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const failureIsUnexpected: <E>(self: Failure<E>) => self is Failure.Unexpected;
+export declare const causeIsDie: <E>(self: MicroCause<E>) => self is MicroCause.Die;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const failureIsAborted: <E>(self: Failure<E>) => self is Failure.Aborted;
+export declare const causeIsInterrupt: <E>(self: MicroCause<E>) => self is MicroCause.Interrupt;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const failureSquash: <E>(self: Failure<E>) => unknown;
+export declare const causeSquash: <E>(self: MicroCause<E>) => unknown;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export declare const failureWithTrace: {
-    (trace: string): <E>(self: Failure<E>) => Failure<E>;
-    <E>(self: Failure<E>, trace: string): Failure<E>;
+export declare const causeWithTrace: {
+    (trace: string): <E>(self: MicroCause<E>) => MicroCause<E>;
+    <E>(self: MicroCause<E>, trace: string): MicroCause<E>;
 };
 /**
- * The Micro Result type is a data type that represents the result of a Micro
+ * @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.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export type Result<A, E = never> = Either.Either<A, Failure<E>>;
+export type MicroExit<A, E = never> = MicroExit.Success<A, E> | MicroExit.Failure<A, E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const ResultAborted: Result<never>;
+export declare const exitInterrupt: MicroExit<never>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const ResultSuccess: <A>(a: A) => Result<A, never>;
+export declare const exitSucceed: <A>(a: A) => MicroExit<A, never>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const ResultFail: <E>(e: E) => Result<never, E>;
+export declare const exitFail: <E>(e: E) => MicroExit<never, E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const ResultFailUnexpected: (defect: unknown) => Result<never>;
+export declare const exitDie: (defect: unknown) => MicroExit<never>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const ResultFailWith: <E>(failure: Failure<E>) => Result<never, E>;
+export declare const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultIsSuccess: <A, E>(self: Result<A, E>) => self is Either.Right<Failure<E>, A>;
+export declare const exitIsSuccess: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Success<A, E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultIsFailure: <A, E>(self: Result<A, E>) => self is Either.Left<Failure<E>, A>;
+export declare const exitIsFailure: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultIsAborted: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Aborted, A>;
+export declare const exitIsInterrupt: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Interrupt, A>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultIsFailureExpected: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Expected<E>, A>;
+export declare const exitIsFail: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Fail<E>, A>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultIsFailureUnexpected: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Unexpected, A>;
+export declare const exitIsDie: <A, E>(self: MicroExit<A, E>) => self is Either.Left<MicroCause.Die, A>;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export declare const resultVoid: Result<void>;
+export declare const exitVoid: MicroExit<void>;
 /**
  * @since 3.4.0
  * @experimental
@@ -472,11 +496,11 @@ export declare const provideService: {
  * 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 environment
  */
-export declare const provideServiceMicro: {
+export declare const provideServiceEffect: {
     <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, 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>;
 };
@@ -545,23 +569,23 @@ export declare const withConcurrency: {
  * @experimental
  * @category constructors
  */
-export declare const make: <A, E, R>(run: (env: Env<R>, onResult: (result: Result<A, E>) => void) => void) => Micro<A, E, R>;
+export declare const make: <R, A, E>(run: (env: Env<R>, onExit: (exit: MicroExit<A, E>) => void) => void) => Micro<A, E, R>;
 /**
- * Converts a `Result` into a `Micro` effect.
+ * Converts a `MicroExit` into a `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category constructors
  */
-export declare const fromResult: <A, E>(self: Result<A, E>) => Micro<A, E>;
+export declare const fromExit: <A, E>(self: MicroExit<A, E>) => Micro<A, E>;
 /**
- * Converts a lazy `Result` into a `Micro` effect.
+ * Converts a lazy `MicroExit` into a `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category constructors
  */
-export declare const fromResultSync: <A, E>(self: LazyArg<Result<A, E>>) => Micro<A, E>;
+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.
  *
@@ -589,7 +613,7 @@ export declare const succeedNone: Micro<Option.Option<never>>;
 /**
  * Creates a `Micro` effect that will fail with the specified error.
  *
- * This will result in a `FailureExpected`, where the error is tracked at the
+ * This will result in a `CauseFail`, where the error is tracked at the
  * type level.
  *
  * @since 3.4.0
@@ -600,7 +624,7 @@ export declare const fail: <E>(e: E) => Micro<never, E>;
 /**
  * Creates a `Micro` effect that will fail with the lazily evaluated error.
  *
- * This will result in a `FailureExpected`, where the error is tracked at the
+ * This will result in a `CauseFail`, where the error is tracked at the
  * type level.
  *
  * @since 3.4.0
@@ -611,7 +635,7 @@ export declare const failSync: <E>(e: LazyArg<E>) => Micro<never, E>;
 /**
  * Creates a `Micro` effect that will die with the specified error.
  *
- * This will result in a `FailureUnexpected`, where the error is not tracked at
+ * This will result in a `CauseDie`, where the error is not tracked at
  * the type level.
  *
  * @since 3.4.0
@@ -620,26 +644,26 @@ export declare const failSync: <E>(e: LazyArg<E>) => Micro<never, E>;
  */
 export declare const die: (defect: unknown) => Micro<never>;
 /**
- * Creates a `Micro` effect that will fail with the specified `Failure`.
+ * Creates a `Micro` effect that will fail with the specified `MicroCause`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category constructors
  */
-export declare const failWith: <E>(failure: Failure<E>) => Micro<never, E>;
+export declare const failCause: <E>(cause: MicroCause<E>) => Micro<never, E>;
 /**
- * Creates a `Micro` effect that will fail with the lazily evaluated `Failure`.
+ * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category constructors
  */
-export declare const failWithSync: <E>(failure: LazyArg<Failure<E>>) => Micro<never, E>;
+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
- * `FailureUnexpected`.
+ * `CauseDie`.
  *
  * @since 3.4.0
  * @experimental
@@ -719,7 +743,7 @@ export {
 try_ as try };
 /**
  * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
- * `FailureUnexpected`.
+ * `CauseDie`.
  *
  * @since 3.4.0
  * @experimental
@@ -878,21 +902,21 @@ export declare const tap: {
  */
 export declare const asVoid: <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>;
 /**
- * Access the `Result` of the given `Micro` effect.
+ * Access the `MicroExit` of the given `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category mapping & sequencing
  */
-export declare const asResult: <A, E, R>(self: Micro<A, E, R>) => Micro<Result<A, E>, never, R>;
+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 `Failure` object.
+ * 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, Failure<E>, R>;
+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
@@ -972,7 +996,7 @@ export declare const zipWith: {
 };
 /**
  * Filter the specified effect with the provided function, failing with specified
- * `Failure` if the predicate fails.
+ * `MicroCause` if the predicate fails.
  *
  * In addition to the filtering capabilities discussed earlier, you have the option to further
  * refine and narrow down the type of the success channel by providing a
@@ -981,11 +1005,11 @@ export declare const zipWith: {
  * @experimental
  * @category filtering & conditionals
  */
-export declare const filterOrFailWith: {
-    <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => Failure<E2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
-    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => Failure<E2>): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
-    <A, E, R, B extends A, E2>(self: Micro<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => Failure<E2>): Micro<B, E | E2, R>;
-    <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => Failure<E2>): Micro<A, E | E2, R>;
+export declare const filterOrFailCause: {
+    <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => MicroCause<E2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => MicroCause<E2>): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
+    <A, E, R, B extends A, E2>(self: Micro<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => MicroCause<E2>): Micro<B, E | E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => MicroCause<E2>): Micro<A, E | E2, R>;
 };
 /**
  * Filter the specified effect with the provided function, failing with specified
@@ -1019,22 +1043,22 @@ export declare const when: {
  * Repeat the given `Micro` using the provided options.
  *
  * The `while` predicate will be checked after each iteration, and can use the
- * fall `Result` of the effect to determine if the repetition should continue.
+ * fall `MicroExit` of the effect to determine if the repetition should continue.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category repetition
  */
-export declare const repeatResult: {
+export declare const repeatExit: {
     <A, E>(options: {
-        while: Predicate<Result<A, E>>;
+        while: Predicate<MicroExit<A, E>>;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     }): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
     <A, E, R>(self: Micro<A, E, R>, options: {
-        while: Predicate<Result<A, E>>;
+        while: Predicate<MicroExit<A, E>>;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     }): Micro<A, E, R>;
 };
 /**
@@ -1049,12 +1073,12 @@ export declare const repeat: {
     <A, E>(options?: {
         while?: Predicate<A> | undefined;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     } | undefined): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
     <A, E, R>(self: Micro<A, E, R>, options?: {
         while?: Predicate<A> | undefined;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     } | undefined): Micro<A, E, R>;
 };
 /**
@@ -1066,164 +1090,197 @@ export declare const repeat: {
  */
 export declare const forever: <A, E, R>(self: Micro<A, E, R>) => Micro<never, E, R>;
 /**
- * Represents a function that can be used to calculate the delay between
- * repeats.
+ * The `MicroSchedule` type represents a function that can be used to calculate
+ * the delay between repeats.
  *
- * The function takes the current attempt number and the elapsed time since
- * the first attempt, and returns the delay for the next attempt. If the
- * function returns `None`, the repetition will stop.
+ * The function takes the current attempt number and the elapsed time since the
+ * first attempt, and returns the delay for the next attempt. If the function
+ * returns `None`, the repetition will stop.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export type DelayFn = (attempt: number, elapsed: number) => Option.Option<number>;
+export type MicroSchedule = (attempt: number, elapsed: number) => Option.Option<number>;
 /**
- * Create a `DelayFn` that will generate a duration with an exponential backoff.
+ * Create a `MicroSchedule` that will stop repeating after the specified number
+ * of attempts.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export declare const delayExponential: (baseMillis: number, factor?: number) => DelayFn;
+export declare const scheduleRecurs: (n: number) => MicroSchedule;
 /**
- * Create a `DelayFn` that will generate a duration with fixed intervals.
+ * Create a `MicroSchedule` that will generate a constant delay.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export declare const delaySpaced: (millis: number) => DelayFn;
+export declare const scheduleSpaced: (millis: number) => MicroSchedule;
 /**
- * Transform a `DelayFn` to one that will have a duration that will never exceed
+ * Create a `MicroSchedule` that will generate a delay with an exponential backoff.
+ *
+ * @since 3.4.6
+ * @experimental
+ * @category scheduling
+ */
+export declare const scheduleExponential: (baseMillis: number, factor?: number) => MicroSchedule;
+/**
+ * Returns a new `MicroSchedule` with an added calculated delay to each delay
+ * returned by this schedule.
+ *
+ * @since 3.4.6
+ * @experimental
+ * @category scheduling
+ */
+export declare const scheduleAddDelay: {
+    (f: () => number): (self: MicroSchedule) => MicroSchedule;
+    (self: MicroSchedule, f: () => number): MicroSchedule;
+};
+/**
+ * Transform a `MicroSchedule` to one that will have a delay that will never exceed
  * the specified maximum.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export declare const delayWithMax: {
-    (max: number): (self: DelayFn) => DelayFn;
-    (self: DelayFn, max: number): DelayFn;
+export declare const scheduleWithMaxDelay: {
+    (max: number): (self: MicroSchedule) => MicroSchedule;
+    (self: MicroSchedule, max: number): MicroSchedule;
 };
 /**
- * Transform a `DelayFn` to one that will stop repeating after the specified
+ * Transform a `MicroSchedule` to one that will stop repeating after the specified
  * amount of time.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export declare const delayWithMaxElapsed: {
-    (max: number): (self: DelayFn) => DelayFn;
-    (self: DelayFn, max: number): DelayFn;
+export declare const scheduleWithMaxElapsed: {
+    (max: number): (self: MicroSchedule) => MicroSchedule;
+    (self: MicroSchedule, max: number): MicroSchedule;
 };
 /**
- * Transform a `DelayFn` to one that will stop repeating after the specified
- * number of attempts.
+ * Combines two `MicroSchedule`s, by recurring if either schedule wants to
+ * recur, using the minimum of the two durations between recurrences.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category delay fn
+ * @category scheduling
  */
-export declare const delayWithRecurs: {
-    (n: number): (self: DelayFn) => DelayFn;
-    (self: DelayFn, n: number): DelayFn;
+export declare const scheduleUnion: {
+    (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule;
+    (self: MicroSchedule, that: MicroSchedule): MicroSchedule;
 };
 /**
- * Catch the full `Failure` object of the given `Micro` effect, allowing you to
- * recover from any kind of failure.
+ * Combines two `MicroSchedule`s, by recurring only if both schedules want to
+ * recur, using the maximum of the two durations between recurrences.
  *
- * @since 3.4.0
+ * @since 3.4.6
+ * @experimental
+ * @category scheduling
+ */
+export declare const scheduleIntersect: {
+    (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule;
+    (self: MicroSchedule, that: MicroSchedule): MicroSchedule;
+};
+/**
+ * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to
+ * recover from any kind of cause.
+ *
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const catchFailure: {
-    <E, B, E2, R2>(f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+export declare const catchAllCause: {
+    <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
 };
 /**
- * Selectively catch a `Failure` object of the given `Micro` effect,
+ * Selectively catch a `MicroCause` object of the given `Micro` effect,
  * using the provided predicate to determine if the failure should be caught.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const catchFailureIf: {
-    <E, B, E2, R2, EB extends Failure<E>>(refinement: Refinement<Failure<E>, EB>, f: (failure: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
-    <E, B, E2, R2>(predicate: Predicate<Failure<NoInfer<E>>>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
-    <A, E, R, B, E2, R2, EB extends Failure<E>>(self: Micro<A, E, R>, refinement: Refinement<Failure<E>, EB>, f: (failure: EB) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: Predicate<Failure<NoInfer<E>>>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+export declare const catchCauseIf: {
+    <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (cause: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>;
+    <E, B, E2, R2>(predicate: Predicate<MicroCause<NoInfer<E>>>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, EB extends MicroCause<E>>(self: Micro<A, E, R>, refinement: Refinement<MicroCause<E>, EB>, f: (cause: EB) => Micro<B, E2, R2>): Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: Predicate<MicroCause<NoInfer<E>>>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>;
 };
 /**
  * Catch the error of the given `Micro` effect, allowing you to recover from it.
  *
- * It only catches expected (`FailureExpected`) errors.
+ * It only catches expected (`MicroCause.Fail`) errors.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const catchExpected: {
+export declare const catchAll: {
     <E, B, E2, R2>(f: (e: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
 };
 /**
  * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const catchUnexpected: {
+export declare const catchAllDefect: {
     <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>;
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>;
 };
 /**
- * Perform a side effect using the full `Failure` object of the given `Micro`.
+ * Perform a side effect using the full `MicroCause` object of the given `Micro`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const tapFailure: {
-    <E, B, E2, R2>(f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+export declare const tapErrorCause: {
+    <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
- * Perform a side effect using if a `Failure` object matches the specified
+ * Perform a side effect using if a `MicroCause` object matches the specified
  * predicate.
  *
  * @since 3.4.0
  * @experimental
  * @category error handling
  */
-export declare const tapFailureIf: {
-    <E, B, E2, R2, EB extends Failure<E>>(refinement: Refinement<Failure<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
-    <E, B, E2, R2>(predicate: (failure: NoInfer<Failure<E>>) => boolean, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
-    <A, E, R, B, E2, R2, EB extends Failure<E>>(self: Micro<A, E, R>, refinement: Refinement<Failure<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: (failure: NoInfer<Failure<E>>) => boolean, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+export declare const tapErrorCauseIf: {
+    <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <E, B, E2, R2>(predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, EB extends MicroCause<E>>(self: Micro<A, E, R>, refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
  * Perform a side effect from expected errors of the given `Micro`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const tapExpected: {
-    <E, B, E2, R2>(f: (a: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
-    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+export declare const tapError: {
+    <E, B, E2, R2>(f: (e: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
  * Perform a side effect from unexpected errors of the given `Micro`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const tapUnexpected: {
+export declare const tapDefect: {
     <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
@@ -1264,15 +1321,15 @@ export declare const catchTag: {
     }>, R | R1>;
 };
 /**
- * Transform the full `Failure` object of the given `Micro` effect.
+ * Transform the full `MicroCause` object of the given `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export declare const mapFailure: {
-    <E, E2>(f: (a: Failure<E>) => Failure<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
-    <A, E, R, E2>(self: Micro<A, E, R>, f: (a: Failure<E>) => Failure<E2>): Micro<A, E2, R>;
+export declare const mapErrorCause: {
+    <E, E2>(f: (e: MicroCause<E>) => MicroCause<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, f: (e: MicroCause<E>) => MicroCause<E2>): Micro<A, E2, R>;
 };
 /**
  * Transform any expected errors of the given `Micro` effect.
@@ -1282,8 +1339,8 @@ export declare const mapFailure: {
  * @category error handling
  */
 export declare const mapError: {
-    <E, E2>(f: (a: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
-    <A, E, R, E2>(self: Micro<A, E, R>, f: (a: E) => E2): Micro<A, E2, R>;
+    <E, E2>(f: (e: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, f: (e: E) => E2): Micro<A, E2, R>;
 };
 /**
  * Elevate any expected errors of the given `Micro` effect to unexpected errors,
@@ -1352,17 +1409,17 @@ export declare const retry: {
     <A, E>(options?: {
         while?: Predicate<E> | undefined;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     } | undefined): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
     <A, E, R>(self: Micro<A, E, R>, options?: {
         while?: Predicate<E> | undefined;
         times?: number | undefined;
-        delay?: DelayFn | undefined;
+        schedule?: MicroSchedule | undefined;
     } | undefined): Micro<A, E, R>;
 };
 /**
  * Add a stack trace to any failures that occur in the effect. The trace will be
- * added to the `traces` field of the `Failure` object.
+ * added to the `traces` field of the `MicroCause` object.
  *
  * @since 3.4.0
  * @experimental
@@ -1373,41 +1430,41 @@ export declare const withTrace: {
     <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>;
 };
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export declare const matchFailureMicro: {
+export declare const matchCauseEffect: {
     <E, A2, E2, R2, A, A3, E3, R3>(options: {
-        readonly onFailure: (failure: Failure<E>) => Micro<A2, E2, R2>;
+        readonly onFailure: (cause: MicroCause<E>) => Micro<A2, E2, R2>;
         readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
     }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
     <A, E, R, A2, E2, R2, A3, E3, R3>(self: Micro<A, E, R>, options: {
-        readonly onFailure: (failure: Failure<E>) => Micro<A2, E2, R2>;
+        readonly onFailure: (cause: MicroCause<E>) => Micro<A2, E2, R2>;
         readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
     }): Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
 };
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export declare const matchFailure: {
+export declare const matchCause: {
     <E, A2, A, A3>(options: {
-        readonly onFailure: (failure: Failure<E>) => A2;
+        readonly onFailure: (cause: MicroCause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
     }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>;
     <A, E, R, A2, A3>(self: Micro<A, E, R>, options: {
-        readonly onFailure: (failure: Failure<E>) => A2;
+        readonly onFailure: (cause: MicroCause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
     }): Micro<A2 | A3, never, R>;
 };
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export declare const matchMicro: {
+export declare const matchEffect: {
     <E, A2, E2, R2, A, A3, E3, R3>(options: {
         readonly onFailure: (e: E) => Micro<A2, E2, R2>;
         readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
@@ -1472,6 +1529,21 @@ export declare const timeoutOrElse: {
         readonly onTimeout: LazyArg<Micro<A2, E2, R2>>;
     }): Micro<A | A2, E | E2, R | R2>;
 };
+/**
+ * Returns an effect that will timeout this effect, that will fail with a
+ * `TimeoutException` if the timeout elapses before the effect has produced a
+ * value.
+ *
+ * If the timeout elapses, the running effect will be safely interrupted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delays & timeouts
+ */
+export declare const timeout: {
+    (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | TimeoutException, R>;
+    <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E | TimeoutException, R>;
+};
 /**
  * Returns an effect that will timeout this effect, succeeding with a `None`
  * if the timeout elapses before the effect has produced a value; and `Some` of
@@ -1483,7 +1555,7 @@ export declare const timeoutOrElse: {
  * @experimental
  * @category delays & timeouts
  */
-export declare const timeout: {
+export declare const timeoutOption: {
     (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
     <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R>;
 };
@@ -1506,7 +1578,7 @@ export type MicroScopeTypeId = typeof MicroScopeTypeId;
  */
 export interface MicroScope {
     readonly [MicroScopeTypeId]: MicroScopeTypeId;
-    readonly addFinalizer: (finalizer: (result: Result<unknown, unknown>) => Micro<void>) => Micro<void>;
+    readonly addFinalizer: (finalizer: (exit: MicroExit<unknown, unknown>) => Micro<void>) => Micro<void>;
     readonly fork: Micro<MicroScope.Closeable>;
 }
 /**
@@ -1521,7 +1593,7 @@ export declare namespace MicroScope {
      * @category resources & finalization
      */
     interface Closeable extends MicroScope {
-        readonly close: (result: Result<any, any>) => Micro<void>;
+        readonly close: (exit: MicroExit<any, any>) => Micro<void>;
     }
 }
 /**
@@ -1578,7 +1650,7 @@ export declare const scoped: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Excl
  * @experimental
  * @category resources & finalization
  */
-export declare const acquireRelease: <A, E, R>(acquire: Micro<A, E, R>, release: (a: A, result: Result<unknown, unknown>) => Micro<void>) => Micro<A, E, R | MicroScope>;
+export declare const acquireRelease: <A, E, R>(acquire: Micro<A, E, R>, release: (a: A, exit: MicroExit<unknown, unknown>) => Micro<void>) => Micro<A, E, R | MicroScope>;
 /**
  * Add a finalizer to the current `MicroScope`.
  *
@@ -1586,32 +1658,32 @@ export declare const acquireRelease: <A, E, R>(acquire: Micro<A, E, R>, release:
  * @experimental
  * @category resources & finalization
  */
-export declare const addFinalizer: (finalizer: (result: Result<unknown, unknown>) => Micro<void>) => Micro<void, never, MicroScope>;
+export declare const addFinalizer: (finalizer: (exit: MicroExit<unknown, unknown>) => Micro<void>) => Micro<void, never, MicroScope>;
 /**
  * When the `Micro` effect is completed, run the given finalizer effect with the
- * `Result` of the executed effect.
+ * `MicroExit` of the executed effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category resources & finalization
  */
-export declare const onResult: {
-    <A, E, XE, XR>(f: (result: Result<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
-    <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (result: Result<A, E>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+export declare const onExit: {
+    <A, E, XE, XR>(f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <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>;
 };
 /**
  * When the `Micro` effect is completed, run the given finalizer effect if it
  * matches the specified predicate.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category resources & finalization
  */
-export declare const onResultIf: {
-    <A, E, XE, XR, B extends Result<A, E>>(refinement: Refinement<Result<A, E>, B>, f: (result: B) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
-    <A, E, XE, XR>(predicate: Predicate<Result<NoInfer<A>, NoInfer<E>>>, f: (result: Result<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
-    <A, E, R, XE, XR, B extends Result<A, E>>(self: Micro<A, E, R>, refinement: Refinement<Result<A, E>, B>, f: (result: B) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
-    <A, E, R, XE, XR>(self: Micro<A, E, R>, predicate: Predicate<Result<NoInfer<A>, NoInfer<E>>>, f: (result: Result<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+export declare const onExitIf: {
+    <A, E, XE, XR, B extends MicroExit<A, E>>(refinement: Refinement<MicroExit<A, E>, B>, f: (exit: B) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, XE, XR>(predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>, f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR, B extends MicroExit<A, E>>(self: Micro<A, E, R>, refinement: Refinement<MicroExit<A, E>, B>, f: (exit: B) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+    <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.
@@ -1626,24 +1698,24 @@ export declare const ensuring: {
 };
 /**
  * When the `Micro` effect fails, run the given finalizer effect with the
- * `Failure` of the executed effect.
+ * `MicroCause` of the executed effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category resources & finalization
  */
-export declare const onFailure: {
-    <A, E, XE, XR>(f: (failure: Failure<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
-    <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (failure: Failure<NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+export declare const onError: {
+    <A, E, XE, XR>(f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
  * If this `Micro` effect is aborted, run the finalizer effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category resources & finalization
  */
-export declare const onAbort: {
+export declare const onInterrupt: {
     <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
     <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
@@ -1655,15 +1727,15 @@ export declare const onAbort: {
  * @experimental
  * @category resources & finalization
  */
-export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acquire: Micro<Resource, E, R>, use: (a: Resource) => Micro<A, E2, R2>, release: (a: Resource, result: Result<A, E2>) => Micro<void, E3, R3>) => Micro<A, E | E2 | E3, R | R2 | R3>;
+export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acquire: Micro<Resource, E, R>, use: (a: Resource) => Micro<A, E2, R2>, release: (a: Resource, exit: MicroExit<A, E2>) => Micro<void, E3, R3>) => Micro<A, E | E2 | E3, R | R2 | R3>;
 /**
  * Abort the current `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category interruption
  */
-export declare const abort: Micro<never>;
+export declare const interrupt: Micro<never>;
 /**
  * Wrap the given `Micro` effect in an uninterruptible region, preventing the
  * effect from being aborted.
@@ -1886,13 +1958,13 @@ export type HandleTypeId = typeof HandleTypeId;
  */
 export interface Handle<A, E = never> {
     readonly [HandleTypeId]: HandleTypeId;
-    readonly await: Micro<Result<A, E>>;
+    readonly await: Micro<MicroExit<A, E>>;
     readonly join: Micro<A, E>;
-    readonly abort: Micro<Result<A, E>>;
-    readonly unsafeAbort: () => void;
-    readonly addObserver: (observer: (result: Result<A, E>) => void) => void;
-    readonly removeObserver: (observer: (result: Result<A, E>) => void) => void;
-    readonly unsafePoll: () => Result<A, E> | null;
+    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;
 }
 /**
  * @since 3.4.0
@@ -1965,8 +2037,8 @@ export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle
  *   Micro.runFork
  * )
  *
- * handle.addObserver((result) => {
- *   console.log(result)
+ * handle.addObserver((exit) => {
+ *   console.log(exit)
  * })
  */
 export declare const runFork: <A, E>(effect: Micro<A, E>, options?: {
@@ -1974,15 +2046,15 @@ export declare const runFork: <A, E>(effect: Micro<A, E>, options?: {
 } | undefined) => Handle<A, E>;
 /**
  * Execute the `Micro` effect and return a `Promise` that resolves with the
- * `Result` of the computation.
+ * `MicroExit` of the computation.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category execution
  */
-export declare const runPromiseResult: <A, E>(effect: Micro<A, E>, options?: {
+export declare const runPromiseExit: <A, E>(effect: Micro<A, E>, options?: {
     readonly signal?: AbortSignal | undefined;
-} | undefined) => Promise<Result<A, E>>;
+} | undefined) => Promise<MicroExit<A, E>>;
 /**
  * Execute the `Micro` effect and return a `Promise` that resolves with the
  * successful value of the computation.
@@ -1995,16 +2067,16 @@ export declare const runPromise: <A, E>(effect: Micro<A, E>, options?: {
     readonly signal?: AbortSignal | undefined;
 } | undefined) => Promise<A>;
 /**
- * Attempt to execute the `Micro` effect synchronously and return the `Result`.
+ * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`.
  *
  * If any asynchronous effects are encountered, the function will return a
- * FailureUnexpected containing the `Handle`.
+ * `CauseDie` containing the `Handle`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category execution
  */
-export declare const runSyncResult: <A, E>(effect: Micro<A, E>) => Result<A, E>;
+export declare const runSyncExit: <A, E>(effect: Micro<A, E>) => MicroExit<A, E>;
 /**
  * Attempt to execute the `Micro` effect synchronously and return the success
  * value.
@@ -2025,7 +2097,7 @@ export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
     readonly [SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>;
     readonly [ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>;
     readonly [TypeId]: Micro.Variance<never, this, never>;
-    readonly [runSymbol]: (env: Env<any>, onResult: (result: Result<never, this>) => void) => void;
+    readonly [runSymbol]: (env: Env<any>, onExit: (exit: MicroExit<never, this>) => void) => void;
     [Symbol.iterator](): MicroIterator<Micro<never, this, never>>;
 }
 /**
@@ -2059,4 +2131,16 @@ export declare class NoSuchElementException extends NoSuchElementException_base<
     message?: string | undefined;
 }> {
 }
+declare const TimeoutException_base: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "TimeoutException";
+} & Readonly<A>;
+/**
+ * Represents a checked exception which occurs when a timeout occurs.
+ *
+ * @since 3.4.4
+ * @experimental
+ * @category errors
+ */
+export declare class TimeoutException extends TimeoutException_base {
+}
 //# sourceMappingURL=Micro.d.ts.map