effect 3.4.5 → 3.4.6

package/dist/esm/Micro.js

@@ -30,33 +30,33 @@ export const runSymbol = /*#__PURE__*/Symbol.for("effect/Micro/runSymbol");
  */
 export const isMicro = u => typeof u === "object" && u !== null && TypeId in u;
 // ----------------------------------------------------------------------------
-// Failures
+// MicroCause
 // ----------------------------------------------------------------------------
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const FailureTypeId = /*#__PURE__*/Symbol.for("effect/Micro/Failure");
-const failureVariance = {
+export const MicroCauseTypeId = /*#__PURE__*/Symbol.for("effect/Micro/MicroCause");
+const microCauseVariance = {
   _E: identity
 };
-class FailureImpl extends globalThis.Error {
+class MicroCauseImpl extends globalThis.Error {
   _tag;
   traces;
-  [FailureTypeId];
+  [MicroCauseTypeId];
   constructor(_tag, originalError, traces) {
-    const failureName = `Failure${_tag}`;
+    const causeName = `MicroCause.${_tag}`;
     let name;
     let message;
     let stack;
     if (originalError instanceof globalThis.Error) {
-      name = `(${failureName}) ${originalError.name}`;
+      name = `(${causeName}) ${originalError.name}`;
       message = originalError.message;
       const messageLines = message.split("\n").length;
-      stack = originalError.stack ? `(${failureName}) ${originalError.stack.split("\n").slice(0, messageLines + 3).join("\n")}` : `${name}: ${message}`;
+      stack = originalError.stack ? `(${causeName}) ${originalError.stack.split("\n").slice(0, messageLines + 3).join("\n")}` : `${name}: ${message}`;
     } else {
-      name = failureName;
+      name = causeName;
       message = toStringUnknown(originalError, 0);
       stack = `${name}: ${message}`;
     }
@@ -66,7 +66,7 @@ class FailureImpl extends globalThis.Error {
     super(message);
     this._tag = _tag;
     this.traces = traces;
-    this[FailureTypeId] = failureVariance;
+    this[MicroCauseTypeId] = microCauseVariance;
     this.name = name;
     this.stack = stack;
   }
@@ -80,146 +80,149 @@ class FailureImpl extends globalThis.Error {
     return this.stack;
   }
 }
-class FailureExpectedImpl extends FailureImpl {
+class FailImpl extends MicroCauseImpl {
   error;
   constructor(error, traces = []) {
-    super("Expected", error, traces);
+    super("Fail", error, traces);
     this.error = error;
   }
 }
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const FailureExpected = (error, traces = []) => new FailureExpectedImpl(error, traces);
-class FailureUnexpectedImpl extends FailureImpl {
+export const causeFail = (error, traces = []) => new FailImpl(error, traces);
+class DieImpl extends MicroCauseImpl {
   defect;
   constructor(defect, traces = []) {
-    super("Unexpected", defect, traces);
+    super("Die", defect, traces);
     this.defect = defect;
   }
 }
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const FailureUnexpected = (defect, traces = []) => new FailureUnexpectedImpl(defect, traces);
-class FailureAbortedImpl extends FailureImpl {
+export const causeDie = (defect, traces = []) => new DieImpl(defect, traces);
+class InterruptImpl extends MicroCauseImpl {
   constructor(traces = []) {
-    super("Aborted", "aborted", traces);
+    super("Interrupt", "interrupted", traces);
   }
 }
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const FailureAborted = (traces = []) => new FailureAbortedImpl(traces);
+export const causeInterrupt = (traces = []) => new InterruptImpl(traces);
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const failureIsExpected = self => self._tag === "Expected";
+export const causeIsFail = self => self._tag === "Fail";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const failureIsUnexpected = self => self._tag === "Unexpected";
+export const causeIsDie = self => self._tag === "Die";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const failureIsAborted = self => self._tag === "Aborted";
+export const causeIsInterrupt = self => self._tag === "Interrupt";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const failureSquash = self => self._tag === "Expected" ? self.error : self._tag === "Unexpected" ? self.defect : self;
+export const causeSquash = self => self._tag === "Fail" ? self.error : self._tag === "Die" ? self.defect : self;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category failure
+ * @category MicroCause
  */
-export const failureWithTrace = /*#__PURE__*/dual(2, (self, trace) => {
-  if (self._tag === "Expected") {
-    return FailureExpected(self.error, [...self.traces, trace]);
-  } else if (self._tag === "Unexpected") {
-    return FailureUnexpected(self.defect, [...self.traces, trace]);
+export const causeWithTrace = /*#__PURE__*/dual(2, (self, trace) => {
+  const traces = [...self.traces, trace];
+  switch (self._tag) {
+    case "Die":
+      return causeDie(self.defect, traces);
+    case "Interrupt":
+      return causeInterrupt(traces);
+    case "Fail":
+      return causeFail(self.error, traces);
   }
-  return FailureAborted([...self.traces, trace]);
 });
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const ResultAborted = /*#__PURE__*/Either.left( /*#__PURE__*/FailureAborted());
+export const exitInterrupt = /*#__PURE__*/Either.left( /*#__PURE__*/causeInterrupt());
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const ResultSuccess = Either.right;
+export const exitSucceed = Either.right;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const ResultFail = e => Either.left(FailureExpected(e));
+export const exitFail = e => Either.left(causeFail(e));
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const ResultFailUnexpected = defect => Either.left(FailureUnexpected(defect));
+export const exitDie = defect => Either.left(causeDie(defect));
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const ResultFailWith = Either.left;
+export const exitFailCause = Either.left;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultIsSuccess = Either.isRight;
+export const exitIsSuccess = Either.isRight;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultIsFailure = Either.isLeft;
+export const exitIsFailure = Either.isLeft;
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultIsAborted = self => resultIsFailure(self) && self.left._tag === "Aborted";
+export const exitIsInterrupt = self => exitIsFailure(self) && self.left._tag === "Interrupt";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultIsFailureExpected = self => resultIsFailure(self) && self.left._tag === "Expected";
+export const exitIsFail = self => exitIsFailure(self) && self.left._tag === "Fail";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultIsFailureUnexpected = self => resultIsFailure(self) && self.left._tag === "Unexpected";
+export const exitIsDie = self => exitIsFailure(self) && self.left._tag === "Die";
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category result
+ * @category MicroExit
  */
-export const resultVoid = /*#__PURE__*/ResultSuccess(void 0);
+export const exitVoid = /*#__PURE__*/exitSucceed(void 0);
 // ----------------------------------------------------------------------------
 // env
 // ----------------------------------------------------------------------------
@@ -294,8 +297,8 @@ export const envMutate = /*#__PURE__*/dual(2, (self, f) => envMake(f(Object.assi
  * @experimental
  * @category environment
  */
-export const service = tag => make(function (env, onResult) {
-  onResult(ResultSuccess(Context.get(envGet(env, currentContext), tag)));
+export const service = tag => make(function (env, onExit) {
+  onExit(exitSucceed(Context.get(envGet(env, currentContext), tag)));
 });
 /**
  * Access the given `Context.Tag` from the environment, without tracking the
@@ -308,8 +311,8 @@ export const service = tag => make(function (env, onResult) {
  * @experimental
  * @category environment
  */
-export const serviceOption = tag => make(function (env, onResult) {
-  onResult(ResultSuccess(Context.getOption(envGet(env, currentContext), tag)));
+export const serviceOption = tag => make(function (env, onExit) {
+  onExit(exitSucceed(Context.getOption(envGet(env, currentContext), tag)));
 });
 /**
  * Retrieve the current value of the given `EnvRef`.
@@ -318,7 +321,7 @@ export const serviceOption = tag => make(function (env, onResult) {
  * @experimental
  * @category environment
  */
-export const getEnvRef = envRef => make((env, onResult) => onResult(Either.right(envGet(env, envRef))));
+export const getEnvRef = envRef => make((env, onExit) => onExit(Either.right(envGet(env, envRef))));
 /**
  * Set the value of the given `EnvRef` for the duration of the effect.
  *
@@ -326,7 +329,7 @@ export const getEnvRef = envRef => make((env, onResult) => onResult(Either.right
  * @experimental
  * @category environment
  */
-export const locally = /*#__PURE__*/dual(3, (self, fiberRef, value) => make((env, onResult) => self[runSymbol](envSet(env, fiberRef, value), onResult)));
+export const locally = /*#__PURE__*/dual(3, (self, fiberRef, value) => make((env, onExit) => self[runSymbol](envSet(env, fiberRef, value), onExit)));
 /**
  * Access the current `Context` from the environment.
  *
@@ -342,10 +345,10 @@ export const context = () => getEnvRef(currentContext);
  * @experimental
  * @category environment
  */
-export const provideContext = /*#__PURE__*/dual(2, (self, provided) => make(function (env, onResult) {
+export const provideContext = /*#__PURE__*/dual(2, (self, provided) => make(function (env, onExit) {
   const context = envGet(env, currentContext);
   const nextEnv = envSet(env, currentContext, Context.merge(context, provided));
-  self[runSymbol](nextEnv, onResult);
+  self[runSymbol](nextEnv, onExit);
 }));
 /**
  * Add the provided service to the current context.
@@ -354,20 +357,20 @@ export const provideContext = /*#__PURE__*/dual(2, (self, provided) => make(func
  * @experimental
  * @category environment
  */
-export const provideService = /*#__PURE__*/dual(3, (self, tag, service) => make(function (env, onResult) {
+export const provideService = /*#__PURE__*/dual(3, (self, tag, service) => make(function (env, onExit) {
   const context = envGet(env, currentContext);
   const nextEnv = envSet(env, currentContext, Context.add(context, tag, service));
-  self[runSymbol](nextEnv, onResult);
+  self[runSymbol](nextEnv, onExit);
 }));
 /**
  * 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 const provideServiceMicro = /*#__PURE__*/dual(3, (self, tag, acquire) => flatMap(acquire, service => provideService(self, tag, service)));
+export const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, acquire) => flatMap(acquire, service => provideService(self, tag, service)));
 // ========================================================================
 // Env refs
 // ========================================================================
@@ -457,21 +460,21 @@ const unsafeMake = run => {
   self[runSymbol] = run;
   return self;
 };
-const unsafeMakeOptions = (run, checkAbort) => unsafeMake(function execute(env, onResult) {
+const unsafeMakeOptions = (run, checkAbort) => unsafeMake(function execute(env, onExit) {
   if (checkAbort && env.refs[currentInterruptible.key] !== false && env.refs[currentAbortSignal.key].aborted) {
-    return onResult(ResultAborted);
+    return onExit(exitInterrupt);
   }
   microDepthState.depth++;
   if (microDepthState.depth === 1) {
     microDepthState.maxDepthBeforeYield = envGet(env, currentMaxDepthBeforeYield);
   }
   if (microDepthState.depth >= microDepthState.maxDepthBeforeYield) {
-    yieldAdd(() => execute(env, onResult));
+    yieldAdd(() => execute(env, onExit));
   } else {
     try {
-      run(env, onResult);
+      run(env, onExit);
     } catch (err) {
-      onResult(ResultFailUnexpected(err));
+      onExit(exitDie(err));
     }
   }
   microDepthState.depth--;
@@ -487,24 +490,24 @@ const unsafeMakeOptions = (run, checkAbort) => unsafeMake(function execute(env,
  */
 export const make = run => unsafeMakeOptions(run, true);
 /**
- * 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 const fromResult = self => make(function (_env, onResult) {
-  onResult(self);
+export const fromExit = self => make(function (_env, onExit) {
+  onExit(self);
 });
 /**
- * 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 const fromResultSync = self => make(function (_env, onResult) {
-  onResult(self());
+export const fromExitSync = self => make(function (_env, onExit) {
+  onExit(self());
 });
 /**
  * Creates a `Micro` effect that will succeed with the specified constant value.
@@ -513,7 +516,7 @@ export const fromResultSync = self => make(function (_env, onResult) {
  * @experimental
  * @category constructors
  */
-export const succeed = a => fromResult(ResultSuccess(a));
+export const succeed = a => fromExit(exitSucceed(a));
 /**
  * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
  *
@@ -533,66 +536,66 @@ export const succeedNone = /*#__PURE__*/succeed( /*#__PURE__*/Option.none());
 /**
  * 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
  * @experimental
  * @category constructors
  */
-export const fail = e => fromResult(ResultFail(e));
+export const fail = e => fromExit(exitFail(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
  * @experimental
  * @category constructors
  */
-export const failSync = e => make(function (_env, onResult) {
-  onResult(ResultFail(e()));
+export const failSync = e => make(function (_env, onExit) {
+  onExit(exitFail(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
  * @experimental
  * @category constructors
  */
-export const die = defect => fromResult(ResultFailUnexpected(defect));
+export const die = defect => fromExit(exitDie(defect));
 /**
- * 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 const failWith = failure => fromResult(ResultFailWith(failure));
+export const failCause = cause => fromExit(exitFailCause(cause));
 /**
- * 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 const failWithSync = failure => fromResultSync(() => ResultFailWith(failure()));
+export const failCauseSync = cause => fromExitSync(() => exitFailCause(cause()));
 /**
  * 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
  * @category constructors
  */
-export const sync = evaluate => make(function (_env, onResult) {
-  onResult(ResultSuccess(evaluate()));
+export const sync = evaluate => make(function (_env, onExit) {
+  onExit(exitSucceed(evaluate()));
 });
 /**
  * Converts an `Option` into a `Micro` effect, that will fail with
@@ -603,8 +606,8 @@ export const sync = evaluate => make(function (_env, onResult) {
  * @experimental
  * @category constructors
  */
-export const fromOption = option => make(function (_env, onResult) {
-  onResult(option._tag === "Some" ? ResultSuccess(option.value) : ResultFail(new NoSuchElementException({})));
+export const fromOption = option => make(function (_env, onExit) {
+  onExit(option._tag === "Some" ? exitSucceed(option.value) : exitFail(new NoSuchElementException({})));
 });
 /**
  * Converts an `Either` into a `Micro` effect, that will fail with the left side
@@ -615,8 +618,8 @@ export const fromOption = option => make(function (_env, onResult) {
  * @experimental
  * @category constructors
  */
-export const fromEither = either => make(function (_env, onResult) {
-  onResult(either._tag === "Right" ? either : ResultFail(either.left));
+export const fromEither = either => make(function (_env, onExit) {
+  onExit(either._tag === "Right" ? either : exitFail(either.left));
 });
 /**
  * Lazily creates a `Micro` effect from the given side-effect.
@@ -625,8 +628,8 @@ export const fromEither = either => make(function (_env, onResult) {
  * @experimental
  * @category constructors
  */
-export const suspend = evaluate => make(function (env, onResult) {
-  evaluate()[runSymbol](env, onResult);
+export const suspend = evaluate => make(function (env, onExit) {
+  evaluate()[runSymbol](env, onExit);
 });
 const void_ = /*#__PURE__*/succeed(void 0);
 export {
@@ -649,16 +652,16 @@ void_ as void };
  * @experimental
  * @category constructors
  */
-export const async = register => make(function (env, onResult) {
+export const async = register => make(function (env, onExit) {
   let resumed = false;
   const controller = register.length > 1 ? new AbortController() : undefined;
   const signal = envGet(env, currentAbortSignal);
   let cleanup = undefined;
   function onAbort() {
     if (cleanup) {
-      resume(uninterruptible(andThen(cleanup, fromResult(ResultAborted))));
+      resume(uninterruptible(andThen(cleanup, fromExit(exitInterrupt))));
     } else {
-      resume(fromResult(ResultAborted));
+      resume(fromExit(exitInterrupt));
     }
     if (controller !== undefined) {
       controller.abort();
@@ -670,17 +673,17 @@ export const async = register => make(function (env, onResult) {
     }
     resumed = true;
     signal.removeEventListener("abort", onAbort);
-    effect[runSymbol](env, onResult);
+    effect[runSymbol](env, onExit);
   }
   cleanup = controller === undefined ? register(resume) : register(resume, controller.signal);
   if (resumed) return;
   signal.addEventListener("abort", onAbort);
 });
-const try_ = options => make(function (_env, onResult) {
+const try_ = options => make(function (_env, onExit) {
   try {
-    onResult(ResultSuccess(options.try()));
+    onExit(exitSucceed(options.try()));
   } catch (err) {
-    onResult(ResultFail(options.catch(err)));
+    onExit(exitFail(options.catch(err)));
   }
 });
 export {
@@ -702,7 +705,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
@@ -763,8 +766,8 @@ const yieldAdd = task => {
  * @experimental
  * @category constructors
  */
-export const yieldNow = /*#__PURE__*/make(function (_env, onResult) {
-  yieldAdd(() => onResult(resultVoid));
+export const yieldNow = /*#__PURE__*/make(function (_env, onExit) {
+  yieldAdd(() => onExit(exitVoid));
 });
 /**
  * Flush any yielded effects that are waiting to be executed.
@@ -795,7 +798,7 @@ export const never = /*#__PURE__*/async(function () {
  * @experimental
  * @category constructors
  */
-export const gen = (...args) => make(function (env, onResult) {
+export const gen = (...args) => make(function (env, onExit) {
   const iterator = args.length === 1 ? args[0]() : args[1].call(args[0]);
   let running = false;
   let value = undefined;
@@ -806,21 +809,21 @@ export const gen = (...args) => make(function (env, onResult) {
       while (shouldContinue) {
         const result = iterator.next(value);
         if (result.done) {
-          return onResult(ResultSuccess(result.value));
+          return onExit(exitSucceed(result.value));
         }
         shouldContinue = false;
-        yieldWrapGet(result.value)[runSymbol](env, function (result) {
-          if (result._tag === "Left") {
-            onResult(result);
+        yieldWrapGet(result.value)[runSymbol](env, function (exit) {
+          if (exit._tag === "Left") {
+            onExit(exit);
           } else {
             shouldContinue = true;
-            value = result.right;
+            value = exit.right;
             if (!running) run();
           }
         });
       }
     } catch (err) {
-      onResult(ResultFailUnexpected(err));
+      onExit(exitDie(err));
     }
     running = false;
   }
@@ -836,8 +839,8 @@ export const gen = (...args) => make(function (env, onResult) {
  * @experimental
  * @category mapping & sequencing
  */
-export const flatten = self => make(function (env, onResult) {
-  self[runSymbol](env, result => result._tag === "Left" ? onResult(result) : result.right[runSymbol](env, onResult));
+export const flatten = self => make(function (env, onExit) {
+  self[runSymbol](env, exit => exit._tag === "Left" ? onExit(exit) : exit.right[runSymbol](env, onExit));
 });
 /**
  * Transforms the success value of the `Micro` effect with the specified
@@ -847,9 +850,9 @@ export const flatten = self => make(function (env, onResult) {
  * @experimental
  * @category mapping & sequencing
  */
-export const map = /*#__PURE__*/dual(2, (self, f) => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
-    onResult(result._tag === "Left" ? result : ResultSuccess(f(result.right)));
+export const map = /*#__PURE__*/dual(2, (self, f) => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
+    onExit(exit._tag === "Left" ? exit : exitSucceed(f(exit.right)));
   });
 }));
 /**
@@ -877,12 +880,12 @@ export const asSome = self => map(self, Option.some);
  * @experimental
  * @category mapping & sequencing
  */
-export const flatMap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
-    if (result._tag === "Left") {
-      return onResult(result);
+export const flatMap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
+    if (exit._tag === "Left") {
+      return onExit(exit);
     }
-    f(result.right)[runSymbol](env, onResult);
+    f(exit.right)[runSymbol](env, onExit);
   });
 }));
 /**
@@ -892,7 +895,7 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onR
  * @experimental
  * @category mapping & sequencing
  */
-export const flip = self => matchMicro(self, {
+export const flip = self => matchEffect(self, {
   onFailure: succeed,
   onSuccess: fail
 });
@@ -907,18 +910,18 @@ export const flip = self => matchMicro(self, {
  * @experimental
  * @category mapping & sequencing
  */
-export const andThen = /*#__PURE__*/dual(2, (self, f) => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
-    if (result._tag === "Left") {
-      return onResult(result);
+export const andThen = /*#__PURE__*/dual(2, (self, f) => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
+    if (exit._tag === "Left") {
+      return onExit(exit);
     } else if (envGet(env, currentAbortSignal).aborted) {
-      return onResult(ResultAborted);
+      return onExit(exitInterrupt);
     }
-    const value = isMicro(f) ? f : typeof f === "function" ? f(result.right) : f;
+    const value = isMicro(f) ? f : typeof f === "function" ? f(exit.right) : f;
     if (isMicro(value)) {
-      value[runSymbol](env, onResult);
+      value[runSymbol](env, onExit);
     } else {
-      onResult(ResultSuccess(value));
+      onExit(exitSucceed(value));
     }
   });
 }));
@@ -931,23 +934,23 @@ export const andThen = /*#__PURE__*/dual(2, (self, f) => make(function (env, onR
  * @experimental
  * @category mapping & sequencing
  */
-export const tap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onResult) {
-  self[runSymbol](env, function (selfResult) {
-    if (selfResult._tag === "Left") {
-      return onResult(selfResult);
+export const tap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onExit) {
+  self[runSymbol](env, function (selfExit) {
+    if (selfExit._tag === "Left") {
+      return onExit(selfExit);
     } else if (envGet(env, currentAbortSignal).aborted) {
-      return onResult(ResultAborted);
+      return onExit(exitInterrupt);
     }
-    const value = isMicro(f) ? f : typeof f === "function" ? f(selfResult.right) : f;
+    const value = isMicro(f) ? f : typeof f === "function" ? f(selfExit.right) : f;
     if (isMicro(value)) {
-      value[runSymbol](env, function (tapResult) {
-        if (tapResult._tag === "Left") {
-          return onResult(tapResult);
+      value[runSymbol](env, function (tapExit) {
+        if (tapExit._tag === "Left") {
+          return onExit(tapExit);
         }
-        onResult(selfResult);
+        onExit(selfExit);
       });
     } else {
-      onResult(selfResult);
+      onExit(selfExit);
     }
   });
 }));
@@ -960,25 +963,25 @@ export const tap = /*#__PURE__*/dual(2, (self, f) => make(function (env, onResul
  */
 export const asVoid = self => map(self, _ => void 0);
 /**
- * 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 const asResult = self => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
-    onResult(ResultSuccess(result));
+export const exit = self => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
+    onExit(exitSucceed(exit));
   });
 });
 /**
- * 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 const sandbox = self => catchFailure(self, failure => fail(failure));
+export const sandbox = self => catchAllCause(self, cause => fail(cause));
 function forkSignal(env) {
   const controller = new AbortController();
   const parentSignal = envGet(env, currentAbortSignal);
@@ -1003,25 +1006,25 @@ function forkSignal(env) {
  * @experimental
  * @category sequencing
  */
-export const raceAll = all => make(function (env, onResult) {
+export const raceAll = all => make(function (env, onExit) {
   const [envWithSignal, onAbort] = forkSignal(env);
   const effects = Array.from(all);
   let len = effects.length;
   let index = 0;
   let done = 0;
-  let result = undefined;
-  const failures = [];
-  function onDone(result_) {
+  let exit = undefined;
+  const causes = [];
+  function onDone(exit_) {
     done++;
-    if (result_._tag === "Right" && result === undefined) {
+    if (exit_._tag === "Right" && exit === undefined) {
       len = index;
-      result = result_;
+      exit = exit_;
       onAbort();
-    } else if (result_._tag === "Left") {
-      failures.push(result_.left);
+    } else if (exit_._tag === "Left") {
+      causes.push(exit_.left);
     }
     if (done >= len) {
-      onResult(result ?? Either.left(failures[0]));
+      onExit(exit ?? Either.left(causes[0]));
     }
   }
   for (; index < len; index++) {
@@ -1037,23 +1040,23 @@ export const raceAll = all => make(function (env, onResult) {
  * @experimental
  * @category sequencing
  */
-export const raceAllFirst = all => make(function (env, onResult) {
+export const raceAllFirst = all => make(function (env, onExit) {
   const [envWithSignal, onAbort] = forkSignal(env);
   const effects = Array.from(all);
   let len = effects.length;
   let index = 0;
   let done = 0;
-  let result = undefined;
-  const failures = [];
-  function onDone(result_) {
+  let exit = undefined;
+  const causes = [];
+  function onDone(exit_) {
     done++;
-    if (result === undefined) {
+    if (exit === undefined) {
       len = index;
-      result = result_;
+      exit = exit_;
       onAbort();
     }
     if (done >= len) {
-      onResult(result ?? Either.left(failures[0]));
+      onExit(exit ?? Either.left(causes[0]));
     }
   }
   for (; index < len; index++) {
@@ -1113,7 +1116,7 @@ export const zipWith = /*#__PURE__*/dual(args => isMicro(args[1]), (self, that,
 // ----------------------------------------------------------------------------
 /**
  * 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
@@ -1122,7 +1125,7 @@ export const zipWith = /*#__PURE__*/dual(args => isMicro(args[1]), (self, that,
  * @experimental
  * @category filtering & conditionals
  */
-export const filterOrFailWith = /*#__PURE__*/dual(args => isMicro(args[0]), (self, refinement, orFailWith) => flatMap(self, a => refinement(a) ? succeed(a) : failWith(orFailWith(a))));
+export const filterOrFailCause = /*#__PURE__*/dual(args => isMicro(args[0]), (self, refinement, orFailWith) => flatMap(self, a => refinement(a) ? succeed(a) : failCause(orFailWith(a))));
 /**
  * Filter the specified effect with the provided function, failing with specified
  * error if the predicate fails.
@@ -1150,34 +1153,34 @@ export const when = /*#__PURE__*/dual(2, (self, condition) => flatMap(isMicro(co
  * 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 const repeatResult = /*#__PURE__*/dual(2, (self, options) => make(function (env, onResult) {
-  const startedAt = options.delay ? Date.now() : 0;
+export const repeatExit = /*#__PURE__*/dual(2, (self, options) => make(function (env, onExit) {
+  const startedAt = options.schedule ? Date.now() : 0;
   let attempt = 0;
-  self[runSymbol](env, function loop(result) {
-    if (options.while !== undefined && !options.while(result)) {
-      return onResult(result);
+  self[runSymbol](env, function loop(exit) {
+    if (options.while !== undefined && !options.while(exit)) {
+      return onExit(exit);
     } else if (options.times !== undefined && attempt >= options.times) {
-      return onResult(result);
+      return onExit(exit);
     }
     attempt++;
     let delayEffect = yieldNow;
-    if (options.delay !== undefined) {
+    if (options.schedule !== undefined) {
       const elapsed = Date.now() - startedAt;
-      const duration = options.delay(attempt, elapsed);
+      const duration = options.schedule(attempt, elapsed);
       if (Option.isNone(duration)) {
-        return onResult(result);
+        return onExit(exit);
       }
       delayEffect = sleep(duration.value);
     }
-    delayEffect[runSymbol](env, function (result) {
-      if (result._tag === "Left") {
-        return onResult(result);
+    delayEffect[runSymbol](env, function (exit) {
+      if (exit._tag === "Left") {
+        return onExit(exit);
       }
       self[runSymbol](env, loop);
     });
@@ -1191,9 +1194,9 @@ export const repeatResult = /*#__PURE__*/dual(2, (self, options) => make(functio
  * @experimental
  * @category repetition
  */
-export const repeat = /*#__PURE__*/dual(args => isMicro(args[0]), (self, options) => repeatResult(self, {
+export const repeat = /*#__PURE__*/dual(args => isMicro(args[0]), (self, options) => repeatExit(self, {
   ...options,
-  while: result => result._tag === "Right" && (options?.while === undefined || options.while(result.right))
+  while: exit => exit._tag === "Right" && (options?.while === undefined || options.while(exit.right))
 }));
 /**
  * Repeat the given `Micro` effect forever, only stopping if the effect fails.
@@ -1204,127 +1207,155 @@ export const repeat = /*#__PURE__*/dual(args => isMicro(args[0]), (self, options
  */
 export const forever = self => repeat(self);
 /**
- * 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 const delayExponential = (baseMillis, factor = 2) => attempt => Option.some(attempt ** factor * baseMillis);
+export const scheduleRecurs = n => attempt => attempt <= n ? Option.some(0) : Option.none();
 /**
- * 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 const delaySpaced = millis => _ => Option.some(millis);
+export const scheduleSpaced = millis => () => Option.some(millis);
 /**
- * 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 const scheduleExponential = (baseMillis, factor = 2) => attempt => Option.some(Math.pow(factor, attempt) * baseMillis);
+/**
+ * Returns a new `MicroSchedule` with an added calculated delay to each delay
+ * returned by this schedule.
+ *
+ * @since 3.4.6
+ * @experimental
+ * @category scheduling
+ */
+export const scheduleAddDelay = /*#__PURE__*/dual(2, (self, f) => (attempt, elapsed) => Option.map(self(attempt, elapsed), duration => duration + f()));
+/**
+ * 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 const delayWithMax = /*#__PURE__*/dual(2, (self, max) => (attempt, elapsed) => Option.map(self(attempt, elapsed), duration => Math.min(duration, max)));
+export const scheduleWithMaxDelay = /*#__PURE__*/dual(2, (self, max) => (attempt, elapsed) => Option.map(self(attempt, elapsed), duration => Math.min(duration, max)));
 /**
- * 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 const delayWithMaxElapsed = /*#__PURE__*/dual(2, (self, max) => (attempt, elapsed) => elapsed < max ? self(attempt, elapsed) : Option.none());
+export const scheduleWithMaxElapsed = /*#__PURE__*/dual(2, (self, max) => (attempt, elapsed) => elapsed < max ? self(attempt, elapsed) : Option.none());
 /**
- * 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 const delayWithRecurs = /*#__PURE__*/dual(2, (self, n) => (attempt, elapsed) => Option.filter(self(attempt, elapsed), () => attempt <= n));
+export const scheduleUnion = /*#__PURE__*/dual(2, (self, that) => (attempt, elapsed) => Option.zipWith(self(attempt, elapsed), that(attempt, elapsed), (d1, d2) => Math.min(d1, d2)));
+/**
+ * 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.6
+ * @experimental
+ * @category scheduling
+ */
+export const scheduleIntersect = /*#__PURE__*/dual(2, (self, that) => (attempt, elapsed) => Option.zipWith(self(attempt, elapsed), that(attempt, elapsed), (d1, d2) => Math.max(d1, d2)));
 // ----------------------------------------------------------------------------
 // error handling
 // ----------------------------------------------------------------------------
 /**
- * Catch the full `Failure` object of the given `Micro` effect, allowing you to
- * recover from any kind of failure.
+ * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to
+ * recover from any kind of cause.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export const catchFailure = /*#__PURE__*/dual(2, (self, f) => catchFailureIf(self, constTrue, f));
+export const catchAllCause = /*#__PURE__*/dual(2, (self, f) => catchCauseIf(self, constTrue, f));
 /**
- * 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 const catchFailureIf = /*#__PURE__*/dual(3, (self, refinement, f) => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
-    if (result._tag === "Right" || !refinement(result.left)) {
-      return onResult(result);
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
+    if (exit._tag === "Right" || !predicate(exit.left)) {
+      onExit(exit);
+    } else {
+      f(exit.left)[runSymbol](env, onExit);
     }
-    f(result.left)[runSymbol](env, onResult);
   });
 }));
 /**
  * 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 const catchExpected = /*#__PURE__*/dual(2, (self, f) => catchFailureIf(self, failureIsExpected, failure => f(failure.error)));
+export const catchAll = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => causeIsFail(cause) ? f(cause.error) : failCause(cause)));
 /**
  * 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 const catchUnexpected = /*#__PURE__*/dual(2, (self, f) => catchFailureIf(self, failureIsUnexpected, failure => f(failure.defect)));
+export const catchAllDefect = /*#__PURE__*/dual(2, (self, f) => catchCauseIf(self, causeIsDie, die => f(die.defect)));
 /**
- * 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 const tapFailure = /*#__PURE__*/dual(2, (self, f) => tapFailureIf(self, constTrue, f));
+export const tapErrorCause = /*#__PURE__*/dual(2, (self, f) => tapErrorCauseIf(self, constTrue, f));
 /**
- * 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 const tapFailureIf = /*#__PURE__*/dual(3, (self, refinement, f) => catchFailureIf(self, refinement, failure => andThen(f(failure), failWith(failure))));
+export const tapErrorCauseIf = /*#__PURE__*/dual(3, (self, refinement, f) => catchCauseIf(self, refinement, cause => andThen(f(cause), failCause(cause))));
 /**
  * Perform a side effect from expected errors of the given `Micro`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export const tapExpected = /*#__PURE__*/dual(2, (self, f) => tapFailureIf(self, failureIsExpected, failure => f(failure.error)));
+export const tapError = /*#__PURE__*/dual(2, (self, f) => tapErrorCauseIf(self, causeIsFail, fail => f(fail.error)));
 /**
  * Perform a side effect from unexpected errors of the given `Micro`.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category error handling
  */
-export const tapUnexpected = /*#__PURE__*/dual(2, (self, f) => tapFailureIf(self, failureIsUnexpected, failure => f(failure.defect)));
+export const tapDefect = /*#__PURE__*/dual(2, (self, f) => tapErrorCauseIf(self, causeIsDie, die => f(die.defect)));
 /**
  * Catch any expected errors that match the specified predicate.
  *
@@ -1332,7 +1363,7 @@ export const tapUnexpected = /*#__PURE__*/dual(2, (self, f) => tapFailureIf(self
  * @experimental
  * @category error handling
  */
-export const catchIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchFailureIf(self, f => failureIsExpected(f) && predicate(f.error), failure => f(failure.error)));
+export const catchIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCauseIf(self, f => causeIsFail(f) && predicate(f.error), fail => f(fail.error)));
 /**
  * Recovers from the specified tagged error.
  *
@@ -1342,13 +1373,13 @@ export const catchIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchFailure
  */
 export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => catchIf(self, isTagged(k), f));
 /**
- * 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 const mapFailure = /*#__PURE__*/dual(2, (self, f) => catchFailure(self, failure => failWith(f(failure))));
+export const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => failCause(f(cause))));
 /**
  * Transform any expected errors of the given `Micro` effect.
  *
@@ -1356,7 +1387,7 @@ export const mapFailure = /*#__PURE__*/dual(2, (self, f) => catchFailure(self, f
  * @experimental
  * @category error handling
  */
-export const mapError = /*#__PURE__*/dual(2, (self, f) => catchExpected(self, error => fail(f(error))));
+export const mapError = /*#__PURE__*/dual(2, (self, f) => catchAll(self, error => fail(f(error))));
 /**
  * Elevate any expected errors of the given `Micro` effect to unexpected errors,
  * resulting in an error type of `never`.
@@ -1365,7 +1396,7 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => catchExpected(self, er
  * @experimental
  * @category error handling
  */
-export const orDie = self => catchExpected(self, die);
+export const orDie = self => catchAll(self, die);
 /**
  * Recover from all errors by succeeding with the given value.
  *
@@ -1373,7 +1404,7 @@ export const orDie = self => catchExpected(self, die);
  * @experimental
  * @category error handling
  */
-export const orElseSucceed = /*#__PURE__*/dual(2, (self, f) => catchExpected(self, _ => sync(f)));
+export const orElseSucceed = /*#__PURE__*/dual(2, (self, f) => catchAll(self, _ => sync(f)));
 /**
  * Ignore any expected errors of the given `Micro` effect, returning `void`.
  *
@@ -1381,7 +1412,7 @@ export const orElseSucceed = /*#__PURE__*/dual(2, (self, f) => catchExpected(sel
  * @experimental
  * @category error handling
  */
-export const ignore = self => matchMicro(self, {
+export const ignore = self => matchEffect(self, {
   onFailure: _ => void_,
   onSuccess: _ => void_
 });
@@ -1392,8 +1423,8 @@ export const ignore = self => matchMicro(self, {
  * @experimental
  * @category error handling
  */
-export const ignoreLogged = self => matchMicro(self, {
-  onFailure: failure => sync(() => console.error(failure)),
+export const ignoreLogged = self => matchEffect(self, {
+  onFailure: error => sync(() => console.error(error)),
   onSuccess: _ => void_
 });
 /**
@@ -1429,13 +1460,13 @@ export const either = self => match(self, {
  * @experimental
  * @category error handling
  */
-export const retry = /*#__PURE__*/dual(args => isMicro(args[0]), (self, options) => repeatResult(self, {
+export const retry = /*#__PURE__*/dual(args => isMicro(args[0]), (self, options) => repeatExit(self, {
   ...options,
-  while: result => result._tag === "Left" && result.left._tag === "Expected" && (options?.while === undefined || options.while(result.left.error))
+  while: exit => exit._tag === "Left" && exit.left._tag === "Fail" && (options?.while === undefined || options.while(exit.left.error))
 }));
 /**
  * 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
@@ -1446,21 +1477,21 @@ export const withTrace = function () {
   globalThis.Error.stackTraceLimit = 2;
   const error = new globalThis.Error();
   globalThis.Error.stackTraceLimit = prevLimit;
-  function generate(name, failure) {
+  function generate(name, cause) {
     const stack = error.stack;
     if (!stack) {
-      return failure;
+      return cause;
     }
     const line = stack.split("\n")[2]?.trim().replace(/^at /, "");
     if (!line) {
-      return failure;
+      return cause;
     }
     const lineMatch = line.match(/\((.*)\)$/);
-    return failureWithTrace(failure, `at ${name} (${lineMatch ? lineMatch[1] : line})`);
+    return causeWithTrace(cause, `at ${name} (${lineMatch ? lineMatch[1] : line})`);
   }
-  const f = name => self => unsafeMakeOptions(function (env, onResult) {
-    self[runSymbol](env, function (result) {
-      onResult(result._tag === "Left" ? Either.left(generate(name, result.left)) : result);
+  const f = name => self => unsafeMakeOptions(function (env, onExit) {
+    self[runSymbol](env, function (exit) {
+      onExit(exit._tag === "Left" ? Either.left(generate(name, exit.left)) : exit);
     });
   }, false);
   if (arguments.length === 2) {
@@ -1472,36 +1503,36 @@ export const withTrace = function () {
 // pattern matching
 // ----------------------------------------------------------------------------
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export const matchFailureMicro = /*#__PURE__*/dual(2, (self, options) => make(function (env, onResult) {
-  self[runSymbol](env, function (result) {
+export const matchCauseEffect = /*#__PURE__*/dual(2, (self, options) => make(function (env, onExit) {
+  self[runSymbol](env, function (exit) {
     try {
-      const next = result._tag === "Left" ? options.onFailure(result.left) : options.onSuccess(result.right);
-      next[runSymbol](env, onResult);
+      const next = exit._tag === "Left" ? options.onFailure(exit.left) : options.onSuccess(exit.right);
+      next[runSymbol](env, onExit);
     } catch (err) {
-      onResult(ResultFailUnexpected(err));
+      onExit(exitDie(err));
     }
   });
 }));
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export const matchFailure = /*#__PURE__*/dual(2, (self, options) => matchFailureMicro(self, {
-  onFailure: failure => sync(() => options.onFailure(failure)),
+export const matchCause = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect(self, {
+  onFailure: cause => sync(() => options.onFailure(cause)),
   onSuccess: value => sync(() => options.onSuccess(value))
 }));
 /**
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category pattern matching
  */
-export const matchMicro = /*#__PURE__*/dual(2, (self, options) => matchFailureMicro(self, {
-  onFailure: failure => failure._tag === "Expected" ? options.onFailure(failure.error) : failWith(failure),
+export const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect(self, {
+  onFailure: cause => cause._tag === "Fail" ? options.onFailure(cause.error) : failCause(cause),
   onSuccess: options.onSuccess
 }));
 /**
@@ -1509,7 +1540,7 @@ export const matchMicro = /*#__PURE__*/dual(2, (self, options) => matchFailureMi
  * @experimental
  * @category pattern matching
  */
-export const match = /*#__PURE__*/dual(2, (self, options) => matchMicro(self, {
+export const match = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
   onFailure: error => sync(() => options.onFailure(error)),
   onSuccess: value => sync(() => options.onSuccess(value))
 }));
@@ -1551,6 +1582,21 @@ export const delay = /*#__PURE__*/dual(2, (self, millis) => andThen(sleep(millis
  * @category delays & timeouts
  */
 export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => raceFirst(self, andThen(interruptible(sleep(options.duration)), options.onTimeout)));
+/**
+ * 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 const timeout = /*#__PURE__*/dual(2, (self, millis) => timeoutOrElse(self, {
+  duration: millis,
+  onTimeout: () => fail(new TimeoutException())
+}));
 /**
  * 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
@@ -1562,7 +1608,7 @@ export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => raceFirst(s
  * @experimental
  * @category delays & timeouts
  */
-export const timeout = /*#__PURE__*/dual(2, (self, millis) => raceFirst(asSome(self), as(interruptible(sleep(millis)), Option.none())));
+export const timeoutOption = /*#__PURE__*/dual(2, (self, millis) => raceFirst(asSome(self), as(interruptible(sleep(millis)), Option.none())));
 // ----------------------------------------------------------------------------
 // resources & finalization
 // ----------------------------------------------------------------------------
@@ -1578,7 +1624,7 @@ export const MicroScopeTypeId = /*#__PURE__*/Symbol.for("effect/Micro/MicroScope
  * @category resources & finalization
  */
 export const MicroScope = /*#__PURE__*/Context.GenericTag("effect/Micro/MicroScope");
-class ScopeImpl {
+class MicroScopeImpl {
   [MicroScopeTypeId];
   state = {
     _tag: "Open",
@@ -1598,7 +1644,7 @@ class ScopeImpl {
         this.state.finalizers.add(finalizer);
         return void_;
       }
-      return finalizer(this.state.result);
+      return finalizer(this.state.exit);
     });
   }
   unsafeRemoveFinalizer(finalizer) {
@@ -1606,28 +1652,28 @@ class ScopeImpl {
       this.state.finalizers.delete(finalizer);
     }
   }
-  close(result) {
+  close(microExit) {
     return suspend(() => {
       if (this.state._tag === "Open") {
         const finalizers = Array.from(this.state.finalizers).reverse();
         this.state = {
           _tag: "Closed",
-          result
+          exit: microExit
         };
-        return flatMap(forEach(finalizers, finalizer => asResult(finalizer(result))), results => asVoid(fromResult(Either.all(results))));
+        return flatMap(forEach(finalizers, finalizer => exit(finalizer(microExit))), exits => asVoid(fromExit(Either.all(exits))));
       }
       return void_;
     });
   }
   get fork() {
     return sync(() => {
-      const newScope = new ScopeImpl();
+      const newScope = new MicroScopeImpl();
       if (this.state._tag === "Closed") {
         newScope.state = this.state;
         return newScope;
       }
-      function fin(result) {
-        return newScope.close(result);
+      function fin(exit) {
+        return newScope.close(exit);
       }
       this.state.finalizers.add(fin);
       newScope.unsafeAddFinalizer(_ => sync(() => this.unsafeRemoveFinalizer(fin)));
@@ -1640,13 +1686,13 @@ class ScopeImpl {
  * @experimental
  * @category resources & finalization
  */
-export const scopeMake = /*#__PURE__*/sync(() => new ScopeImpl());
+export const scopeMake = /*#__PURE__*/sync(() => new MicroScopeImpl());
 /**
  * @since 3.4.0
  * @experimental
  * @category resources & finalization
  */
-export const scopeUnsafeMake = () => new ScopeImpl();
+export const scopeUnsafeMake = () => new MicroScopeImpl();
 /**
  * Access the current `MicroScope`.
  *
@@ -1672,8 +1718,8 @@ export const provideScope = /*#__PURE__*/dual(2, (self, scope) => provideService
  * @category resources & finalization
  */
 export const scoped = self => suspend(function () {
-  const scope = new ScopeImpl();
-  return onResult(provideService(self, MicroScope, scope), result => scope.close(result));
+  const scope = new MicroScopeImpl();
+  return onExit(provideService(self, MicroScope, scope), exit => scope.close(exit));
 });
 /**
  * Create a resource with a cleanup `Micro` effect, ensuring the cleanup is
@@ -1683,7 +1729,7 @@ export const scoped = self => suspend(function () {
  * @experimental
  * @category resources & finalization
  */
-export const acquireRelease = (acquire, release) => uninterruptible(flatMap(scope, scope => tap(acquire, a => scope.addFinalizer(result => release(a, result)))));
+export const acquireRelease = (acquire, release) => uninterruptible(flatMap(scope, scope => tap(acquire, a => scope.addFinalizer(exit => release(a, exit)))));
 /**
  * Add a finalizer to the current `MicroScope`.
  *
@@ -1694,31 +1740,31 @@ export const acquireRelease = (acquire, release) => uninterruptible(flatMap(scop
 export const addFinalizer = finalizer => flatMap(scope, scope => scope.addFinalizer(finalizer));
 /**
  * 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 const onResult = /*#__PURE__*/dual(2, (self, f) => onResultIf(self, constTrue, f));
+export const onExit = /*#__PURE__*/dual(2, (self, f) => onExitIf(self, constTrue, f));
 /**
  * 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 const onResultIf = /*#__PURE__*/dual(3, (self, refinement, f) => uninterruptibleMask(restore => make(function (env, onResult) {
-  restore(self)[runSymbol](env, function (result) {
-    if (!refinement(result)) {
-      return onResult(result);
+export const onExitIf = /*#__PURE__*/dual(3, (self, refinement, f) => uninterruptibleMask(restore => make(function (env, onExit) {
+  restore(self)[runSymbol](env, function (exit) {
+    if (!refinement(exit)) {
+      return onExit(exit);
     }
-    f(result)[runSymbol](env, function (finalizerResult) {
-      if (finalizerResult._tag === "Left") {
-        return onResult(finalizerResult);
+    f(exit)[runSymbol](env, function (finalizerExit) {
+      if (finalizerExit._tag === "Left") {
+        return onExit(finalizerExit);
       }
-      onResult(result);
+      onExit(exit);
     });
   });
 })));
@@ -1729,24 +1775,24 @@ export const onResultIf = /*#__PURE__*/dual(3, (self, refinement, f) => uninterr
  * @experimental
  * @category resources & finalization
  */
-export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => onResult(self, _ => finalizer));
+export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => onExit(self, _ => finalizer));
 /**
  * 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 const onFailure = /*#__PURE__*/dual(2, (self, f) => onResultIf(self, resultIsFailure, result => f(result.left)));
+export const onError = /*#__PURE__*/dual(2, (self, f) => onExitIf(self, exitIsFailure, exit => f(exit.left)));
 /**
  * If this `Micro` effect is aborted, run the finalizer effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category resources & finalization
  */
-export const onAbort = /*#__PURE__*/dual(2, (self, finalizer) => onResultIf(self, resultIsAborted, _ => finalizer));
+export const onInterrupt = /*#__PURE__*/dual(2, (self, finalizer) => onExitIf(self, exitIsInterrupt, _ => finalizer));
 /**
  * Acquire a resource, use it, and then release the resource when the `use`
  * effect has completed.
@@ -1755,21 +1801,21 @@ export const onAbort = /*#__PURE__*/dual(2, (self, finalizer) => onResultIf(self
  * @experimental
  * @category resources & finalization
  */
-export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(asResult(restore(use(a))), result => andThen(release(a, result), fromResult(result)))));
+export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(exit(restore(use(a))), exit => andThen(release(a, exit), fromExit(exit)))));
 // ----------------------------------------------------------------------------
 // interruption
 // ----------------------------------------------------------------------------
 /**
  * Abort the current `Micro` effect.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
  * @category interruption
  */
-export const abort = /*#__PURE__*/make(function (env, onResult) {
+export const interrupt = /*#__PURE__*/make(function (env, onExit) {
   const controller = envGet(env, currentAbortController);
   controller.abort();
-  onResult(ResultAborted);
+  onExit(exitInterrupt);
 });
 /**
  * Wrap the given `Micro` effect in an uninterruptible region, preventing the
@@ -1779,13 +1825,13 @@ export const abort = /*#__PURE__*/make(function (env, onResult) {
  * @experimental
  * @category interruption
  */
-export const uninterruptible = self => unsafeMakeOptions(function (env, onResult) {
+export const uninterruptible = self => unsafeMakeOptions(function (env, onExit) {
   const nextEnv = envMutate(env, function (env) {
     env[currentInterruptible.key] = false;
     env[currentAbortSignal.key] = new AbortController().signal;
     return env;
   });
-  self[runSymbol](nextEnv, onResult);
+  self[runSymbol](nextEnv, onExit);
 }, false);
 /**
  * Wrap the given `Micro` effect in an uninterruptible region, preventing the
@@ -1806,7 +1852,7 @@ export const uninterruptible = self => unsafeMakeOptions(function (env, onResult
  *   )
  * )
  */
-export const uninterruptibleMask = f => unsafeMakeOptions((env, onResult) => {
+export const uninterruptibleMask = f => unsafeMakeOptions((env, onExit) => {
   const isInterruptible = envGet(env, currentInterruptible);
   const effect = isInterruptible ? f(interruptible) : f(identity);
   const nextEnv = isInterruptible ? envMutate(env, function (env) {
@@ -1814,7 +1860,7 @@ export const uninterruptibleMask = f => unsafeMakeOptions((env, onResult) => {
     env[currentAbortSignal.key] = new AbortController().signal;
     return env;
   }) : env;
-  effect[runSymbol](nextEnv, onResult);
+  effect[runSymbol](nextEnv, onExit);
 }, false);
 /**
  * Wrap the given `Micro` effect in an interruptible region, allowing the effect
@@ -1824,7 +1870,7 @@ export const uninterruptibleMask = f => unsafeMakeOptions((env, onResult) => {
  * @experimental
  * @category interruption
  */
-export const interruptible = self => make((env, onResult) => {
+export const interruptible = self => make((env, onExit) => {
   const isInterruptible = envGet(env, currentInterruptible);
   let newEnv = env;
   if (!isInterruptible) {
@@ -1835,7 +1881,7 @@ export const interruptible = self => make((env, onResult) => {
       return env;
     });
   }
-  self[runSymbol](newEnv, onResult);
+  self[runSymbol](newEnv, onExit);
 });
 /**
  * Runs all the provided effects in sequence respecting the structure provided in input.
@@ -1875,13 +1921,13 @@ export const all = (arg, options) => {
  * @experimental
  * @category collecting & elements
  */
-export const forEach = (iterable, f, options) => make(function (env, onResult) {
+export const forEach = (iterable, f, options) => make(function (env, onExit) {
   const concurrencyOption = options?.concurrency === "inherit" ? envGet(env, currentConcurrency) : options?.concurrency ?? 1;
   const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
   // abort
   const [envWithSignal, onAbort] = forkSignal(env);
   // iterate
-  let failure = undefined;
+  let result = undefined;
   const items = Array.from(iterable);
   let length = items.length;
   const out = options?.discard ? undefined : new Array(length);
@@ -1897,26 +1943,26 @@ export const forEach = (iterable, f, options) => make(function (env, onResult) {
       index++;
       inProgress++;
       try {
-        f(item, currentIndex)[runSymbol](envWithSignal, function (result) {
-          if (result._tag === "Left") {
-            if (failure === undefined) {
-              failure = result;
+        f(item, currentIndex)[runSymbol](envWithSignal, function (exit) {
+          if (exit._tag === "Left") {
+            if (result === undefined) {
+              result = exit;
               length = index;
               onAbort();
             }
           } else if (out !== undefined) {
-            out[currentIndex] = result.right;
+            out[currentIndex] = exit.right;
           }
           doneCount++;
           inProgress--;
           if (doneCount === length) {
-            onResult(failure ?? Either.right(out));
+            onExit(result ?? Either.right(out));
           } else if (!pumping && inProgress < concurrency) {
             pump();
           }
         });
       } catch (err) {
-        failure = ResultFailUnexpected(err);
+        result = exitDie(err);
         length = index;
         onAbort();
       }
@@ -1937,7 +1983,7 @@ export const forEach = (iterable, f, options) => make(function (env, onResult) {
 export const filter = (iterable, f, options) => filterMap(iterable, a => map(f(a), pass => {
   pass = options?.negate ? !pass : pass;
   return pass ? Option.some(a) : Option.none();
-}));
+}), options);
 /**
  * Effectfully filter the elements of the provided iterable.
  *
@@ -2014,7 +2060,7 @@ class HandleImpl {
   parentSignal;
   [HandleTypeId];
   observers = new Set();
-  _result = undefined;
+  _exit = undefined;
   _controller;
   isRoot;
   constructor(parentSignal, controller) {
@@ -2023,29 +2069,29 @@ class HandleImpl {
     this.isRoot = controller !== undefined;
     this._controller = controller ?? new AbortController();
     if (!this.isRoot) {
-      parentSignal.addEventListener("abort", this.unsafeAbort);
+      parentSignal.addEventListener("abort", this.unsafeInterrupt);
     }
   }
   unsafePoll() {
-    return this._result ?? null;
+    return this._exit ?? null;
   }
-  unsafeAbort = () => {
+  unsafeInterrupt = () => {
     this._controller.abort();
   };
-  emit(result) {
-    if (this._result) {
+  emit(exit) {
+    if (this._exit) {
       return;
     }
-    this._result = result;
+    this._exit = exit;
     if (!this.isRoot) {
-      this.parentSignal.removeEventListener("abort", this.unsafeAbort);
+      this.parentSignal.removeEventListener("abort", this.unsafeInterrupt);
     }
-    this.observers.forEach(observer => observer(result));
+    this.observers.forEach(observer => observer(exit));
     this.observers.clear();
   }
   addObserver(observer) {
-    if (this._result) {
-      return observer(this._result);
+    if (this._exit) {
+      return observer(this._exit);
     }
     this.observers.add(observer);
   }
@@ -2054,12 +2100,12 @@ class HandleImpl {
   }
   get await() {
     return suspend(() => {
-      if (this._result) {
-        return succeed(this._result);
+      if (this._exit) {
+        return succeed(this._exit);
       }
       return async(resume => {
-        function observer(result) {
-          resume(succeed(result));
+        function observer(exit) {
+          resume(succeed(exit));
         }
         this.addObserver(observer);
         return sync(() => {
@@ -2069,11 +2115,11 @@ class HandleImpl {
     });
   }
   get join() {
-    return flatMap(this.await, fromResult);
+    return flatMap(this.await, fromExit);
   }
-  get abort() {
+  get interrupt() {
     return suspend(() => {
-      this.unsafeAbort();
+      this.unsafeInterrupt();
       return this.await;
     });
   }
@@ -2088,7 +2134,7 @@ class HandleImpl {
  * @experimental
  * @category handle & forking
  */
-export const fork = self => make(function (env, onResult) {
+export const fork = self => make(function (env, onExit) {
   const signal = envGet(env, currentAbortSignal);
   const handle = new HandleImpl(signal);
   const nextEnv = envMutate(env, map => {
@@ -2097,11 +2143,11 @@ export const fork = self => make(function (env, onResult) {
     return map;
   });
   yieldAdd(() => {
-    self[runSymbol](nextEnv, result => {
-      handle.emit(result);
+    self[runSymbol](nextEnv, exit => {
+      handle.emit(exit);
     });
   });
-  onResult(Either.right(handle));
+  onExit(Either.right(handle));
 });
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
@@ -2113,7 +2159,7 @@ export const fork = self => make(function (env, onResult) {
  * @experimental
  * @category handle & forking
  */
-export const forkDaemon = self => make(function (env, onResult) {
+export const forkDaemon = self => make(function (env, onExit) {
   const controller = new AbortController();
   const handle = new HandleImpl(controller.signal, controller);
   const nextEnv = envMutate(env, map => {
@@ -2122,11 +2168,11 @@ export const forkDaemon = self => make(function (env, onResult) {
     return map;
   });
   yieldAdd(() => {
-    self[runSymbol](nextEnv, result => {
-      handle.emit(result);
+    self[runSymbol](nextEnv, exit => {
+      handle.emit(exit);
     });
   });
-  onResult(Either.right(handle));
+  onExit(Either.right(handle));
 });
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
@@ -2138,7 +2184,7 @@ export const forkDaemon = self => make(function (env, onResult) {
  * @experimental
  * @category handle & forking
  */
-export const forkIn = /*#__PURE__*/dual(2, (self, scope) => uninterruptibleMask(restore => flatMap(scope.fork, scope => tap(restore(forkDaemon(onResult(self, result => scope.close(result)))), fiber => scope.addFinalizer(_ => asVoid(fiber.abort))))));
+export const forkIn = /*#__PURE__*/dual(2, (self, scope) => uninterruptibleMask(restore => flatMap(scope.fork, scope => tap(restore(forkDaemon(onExit(self, exit => scope.close(exit)))), fiber => scope.addFinalizer(_ => asVoid(fiber.interrupt))))));
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -2171,8 +2217,8 @@ export const forkScoped = self => flatMap(scope, scope => forkIn(self, scope));
  *   Micro.runFork
  * )
  *
- * handle.addObserver((result) => {
- *   console.log(result)
+ * handle.addObserver((exit) => {
+ *   console.log(exit)
  * })
  */
 export const runFork = (effect, options) => {
@@ -2182,17 +2228,17 @@ export const runFork = (effect, options) => {
   refs[currentAbortSignal.key] = controller.signal;
   const env = envMake(refs);
   const handle = new HandleImpl(controller.signal, controller);
-  effect[runSymbol](envSet(env, currentAbortSignal, handle._controller.signal), result => {
-    handle.emit(result);
+  effect[runSymbol](envSet(env, currentAbortSignal, handle._controller.signal), exit => {
+    handle.emit(exit);
     if (options?.signal) {
-      options.signal.removeEventListener("abort", handle.unsafeAbort);
+      options.signal.removeEventListener("abort", handle.unsafeInterrupt);
     }
   });
   if (options?.signal) {
     if (options.signal.aborted) {
-      handle.unsafeAbort();
+      handle.unsafeInterrupt();
     } else {
-      options.signal.addEventListener("abort", handle.unsafeAbort, {
+      options.signal.addEventListener("abort", handle.unsafeInterrupt, {
         once: true
       });
     }
@@ -2201,13 +2247,13 @@ export const runFork = (effect, options) => {
 };
 /**
  * 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 const runPromiseResult = (effect, options) => new Promise((resolve, _reject) => {
+export const runPromiseExit = (effect, options) => new Promise((resolve, _reject) => {
   const handle = runFork(effect, options);
   handle.addObserver(resolve);
 });
@@ -2219,32 +2265,32 @@ export const runPromiseResult = (effect, options) => new Promise((resolve, _reje
  * @experimental
  * @category execution
  */
-export const runPromise = (effect, options) => runPromiseResult(effect, options).then(result => {
-  if (result._tag === "Left") {
-    throw result.left;
+export const runPromise = (effect, options) => runPromiseExit(effect, options).then(exit => {
+  if (exit._tag === "Left") {
+    throw exit.left;
   }
-  return result.right;
+  return exit.right;
 });
 /**
- * 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 const runSyncResult = effect => {
+export const runSyncExit = effect => {
   const handle = runFork(effect);
   while (yieldState.tasks.length > 0) {
     yieldRunTasks();
   }
-  const result = handle.unsafePoll();
-  if (result === null) {
-    return ResultFailUnexpected(handle);
+  const exit = handle.unsafePoll();
+  if (exit === null) {
+    return exitDie(handle);
   }
-  return result;
+  return exit;
 };
 /**
  * Attempt to execute the `Micro` effect synchronously and return the success
@@ -2255,16 +2301,16 @@ export const runSyncResult = effect => {
  * @category execution
  */
 export const runSync = effect => {
-  const result = runSyncResult(effect);
-  if (result._tag === "Left") {
-    throw result.left;
+  const exit = runSyncExit(effect);
+  if (exit._tag === "Left") {
+    throw exit.left;
   }
-  return result.right;
+  return exit.right;
 };
 const YieldableError = /*#__PURE__*/function () {
   class YieldableError extends globalThis.Error {
-    [runSymbol](_env, onResult) {
-      onResult(ResultFail(this));
+    [runSymbol](_env, onExit) {
+      onExit(exitFail(this));
     }
     toString() {
       return this.message ? `${this.name}: ${this.message}` : this.name;
@@ -2322,4 +2368,12 @@ export const TaggedError = tag => {
  * @category errors
  */
 export class NoSuchElementException extends TaggedError("NoSuchElementException") {}
+/**
+ * Represents a checked exception which occurs when a timeout occurs.
+ *
+ * @since 3.4.4
+ * @experimental
+ * @category errors
+ */
+export class TimeoutException extends TaggedError("TimeoutException") {}
 //# sourceMappingURL=Micro.js.map