effect 3.10.19 → 3.11.0

package/src/Micro.ts

@@ -4,28 +4,33 @@
  * @since 3.4.0
  * @experimental
  */
-import type { Channel, ChannelTypeId } from "./Channel.js"
+import * as Arr from "effect/Array"
+import type { Channel } from "./Channel.js"
 import * as Context from "./Context.js"
-import type { Effect, EffectTypeId, EffectUnify, EffectUnifyIgnore } from "./Effect.js"
+import type { Effect, EffectUnify, EffectUnifyIgnore } from "./Effect.js"
 import * as Effectable from "./Effectable.js"
 import * as Either from "./Either.js"
-import { constTrue, constVoid, dual, identity, type LazyArg } from "./Function.js"
+import * as Equal from "./Equal.js"
+import type { LazyArg } from "./Function.js"
+import { constTrue, constVoid, dual, identity } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
+import * as Hash from "./Hash.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
-import { NodeInspectSymbol, toStringUnknown } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toStringUnknown } from "./Inspectable.js"
+import * as InternalContext from "./internal/context.js"
 import * as doNotation from "./internal/doNotation.js"
 import { StructuralPrototype } from "./internal/effectable.js"
-import { SingleShotGen } from "./internal/singleShotGen.js"
 import * as Option from "./Option.js"
-import { type Pipeable, pipeArguments } from "./Pipeable.js"
-import { hasProperty, isIterable, isTagged, type Predicate, type Refinement } from "./Predicate.js"
-import type { ReadonlyRecord } from "./Record.js"
-import type { Sink, SinkTypeId } from "./Sink.js"
-import type { Stream, StreamTypeId } from "./Stream.js"
-import type { Concurrency, Covariant, Equals, NoInfer, NotFunction, Simplify } from "./Types.js"
+import type { Pipeable } from "./Pipeable.js"
+import { pipeArguments } from "./Pipeable.js"
+import type { Predicate, Refinement } from "./Predicate.js"
+import { hasProperty, isIterable, isTagged } from "./Predicate.js"
+import type { Sink } from "./Sink.js"
+import type { Stream } from "./Stream.js"
+import type { Concurrency, Covariant, Equals, NotFunction, Simplify } from "./Types.js"
 import type * as Unify from "./Unify.js"
-import { YieldWrap, yieldWrapGet } from "./Utils.js"
+import { SingleShotGen, YieldWrap, yieldWrapGet } from "./Utils.js"
 
 /**
  * @since 3.4.0
@@ -44,16 +49,18 @@ export type TypeId = typeof TypeId
 /**
  * @since 3.4.0
  * @experimental
- * @category symbols
+ * @category MicroExit
  */
-export const runSymbol: unique symbol = Symbol.for("effect/Micro/runSymbol")
+export const MicroExitTypeId: unique symbol = Symbol.for(
+  "effect/Micro/MicroExit"
+)
 
 /**
  * @since 3.4.0
  * @experimental
- * @category symbols
+ * @category MicroExit
  */
-export type runSymbol = typeof runSymbol
+export type MicroExitTypeId = typeof TypeId
 
 /**
  * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
@@ -64,7 +71,6 @@ export type runSymbol = typeof runSymbol
  */
 export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
   readonly [TypeId]: Micro.Variance<A, E, R>
-  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void
   [Symbol.iterator](): MicroIterator<Micro<A, E, R>>
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: MicroUnify<this>
@@ -144,58 +150,6 @@ export interface MicroIterator<T extends Micro<any, any, any>> {
   next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>
 }
 
-/**
- * @since 3.8.4
- * @experimental
- * @category models
- */
-export interface MicroClass {
-  new<A, E = never, R = never>(): Micro<A, E, R>
-}
-
-// ----------------------------------------------------------------------------
-// Microable
-// ----------------------------------------------------------------------------
-
-const MicroProto = {
-  ...Effectable.EffectPrototype,
-  _op: "Micro",
-  [TypeId]: {
-    _A: identity,
-    _E: identity,
-    _R: identity
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this)) as any
-  }
-}
-
-const MicroBase: MicroClass = (function() {
-  function Base() {}
-  Base.prototype = MicroProto
-  return Base as any
-})()
-
-/**
- * @since 3.8.4
- * @experimental
- * @category constructors
- */
-export abstract class Class<out A, out E = never, out R = never> extends MicroBase<A, E, R> {
-  /**
-   * @since 3.8.4
-   * @experimental
-   */
-  abstract asMicro(): Micro<A, E, R>
-  /**
-   * @since 3.8.4
-   * @experimental
-   */
-  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<A, E>) => void): void {
-    this.asMicro()[runSymbol](env, onExit)
-  }
-}
-
 // ----------------------------------------------------------------------------
 // MicroCause
 // ----------------------------------------------------------------------------
@@ -221,7 +175,10 @@ export type MicroCauseTypeId = typeof MicroCauseTypeId
  * @experimental
  * @category MicroCause
  */
-export type MicroCause<E> = MicroCause.Die | MicroCause.Fail<E> | MicroCause.Interrupt
+export type MicroCause<E> =
+  | MicroCause.Die
+  | MicroCause.Fail<E>
+  | MicroCause.Interrupt
 
 /**
  * @since 3.6.6
@@ -302,7 +259,12 @@ abstract class MicroCauseImpl<Tag extends string, E> extends globalThis.Error im
       message = originalError.message as string
       const messageLines = message.split("\n").length
       stack = originalError.stack
-        ? `(${causeName}) ${originalError.stack.split("\n").slice(0, messageLines + 3).join("\n")}`
+        ? `(${causeName}) ${
+          originalError.stack
+            .split("\n")
+            .slice(0, messageLines + 3)
+            .join("\n")
+        }`
         : `${name}: ${message}`
     } else {
       name = causeName
@@ -329,7 +291,10 @@ abstract class MicroCauseImpl<Tag extends string, E> extends globalThis.Error im
 }
 
 class FailImpl<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E> {
-  constructor(readonly error: E, traces: ReadonlyArray<string> = []) {
+  constructor(
+    readonly error: E,
+    traces: ReadonlyArray<string> = []
+  ) {
     super("Fail", error, traces)
   }
 }
@@ -339,10 +304,16 @@ class FailImpl<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E
  * @experimental
  * @category MicroCause
  */
-export const causeFail = <E>(error: E, traces: ReadonlyArray<string> = []): MicroCause<E> => new FailImpl(error, traces)
+export const causeFail = <E>(
+  error: E,
+  traces: ReadonlyArray<string> = []
+): MicroCause<E> => new FailImpl(error, traces)
 
 class DieImpl extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
-  constructor(readonly defect: unknown, traces: ReadonlyArray<string> = []) {
+  constructor(
+    readonly defect: unknown,
+    traces: ReadonlyArray<string> = []
+  ) {
     super("Die", defect, traces)
   }
 }
@@ -352,8 +323,10 @@ class DieImpl extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
  * @experimental
  * @category MicroCause
  */
-export const causeDie = (defect: unknown, traces: ReadonlyArray<string> = []): MicroCause<never> =>
-  new DieImpl(defect, traces)
+export const causeDie = (
+  defect: unknown,
+  traces: ReadonlyArray<string> = []
+): MicroCause<never> => new DieImpl(defect, traces)
 
 class InterruptImpl extends MicroCauseImpl<"Interrupt", never> implements MicroCause.Interrupt {
   constructor(traces: ReadonlyArray<string> = []) {
@@ -366,14 +339,18 @@ class InterruptImpl extends MicroCauseImpl<"Interrupt", never> implements MicroC
  * @experimental
  * @category MicroCause
  */
-export const causeInterrupt = (traces: ReadonlyArray<string> = []): MicroCause<never> => new InterruptImpl(traces)
+export const causeInterrupt = (
+  traces: ReadonlyArray<string> = []
+): MicroCause<never> => new InterruptImpl(traces)
 
 /**
  * @since 3.4.6
  * @experimental
  * @category MicroCause
  */
-export const causeIsFail = <E>(self: MicroCause<E>): self is MicroCause.Fail<E> => self._tag === "Fail"
+export const causeIsFail = <E>(
+  self: MicroCause<E>
+): self is MicroCause.Fail<E> => self._tag === "Fail"
 
 /**
  * @since 3.4.6
@@ -387,7 +364,9 @@ export const causeIsDie = <E>(self: MicroCause<E>): self is MicroCause.Die => se
  * @experimental
  * @category MicroCause
  */
-export const causeIsInterrupt = <E>(self: MicroCause<E>): self is MicroCause.Interrupt => self._tag === "Interrupt"
+export const causeIsInterrupt = <E>(
+  self: MicroCause<E>
+): self is MicroCause.Interrupt => self._tag === "Interrupt"
 
 /**
  * @since 3.4.6
@@ -428,1690 +407,1963 @@ export const causeWithTrace: {
 })
 
 // ----------------------------------------------------------------------------
-// MicroExit
+// Fiber
 // ----------------------------------------------------------------------------
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export declare namespace MicroExit {
-  /**
-   * @since 3.4.6
-   * @experimental
-   * @category MicroExit
-   */
-  export type Success<A, E = never> = Either.Right<MicroCause<E>, A>
-
-  /**
-   * @since 3.4.6
-   * @experimental
-   * @category MicroExit
-   */
-  export type Failure<A, E = never> = Either.Left<MicroCause<E>, A>
-}
+export const FiberTypeId = Symbol.for("effect/Micro/Fiber")
 
 /**
- * The MicroExit type is a data type that represents the result of a Micro
- * computation.
- *
- * It uses the `Either` data type to represent the success and failure cases.
- *
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export type MicroExit<A, E = never> = MicroExit.Success<A, E> | MicroExit.Failure<A, E>
+export type FiberTypeId = typeof FiberTypeId
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export const exitInterrupt: MicroExit<never> = Either.left(causeInterrupt())
+export interface Fiber<out A, out E = never> {
+  readonly [FiberTypeId]: Fiber.Variance<A, E>
 
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitSucceed: <A>(a: A) => MicroExit<A, never> = Either.right
+  readonly currentOpCount: number
+  readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A
+  readonly context: Context.Context<never>
+  readonly addObserver: (cb: (exit: MicroExit<A, E>) => void) => () => void
+  readonly unsafeInterrupt: () => void
+  readonly unsafePoll: () => MicroExit<A, E> | undefined
+}
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export const exitFail = <E>(e: E): MicroExit<never, E> => Either.left(causeFail(e))
+export declare namespace Fiber {
+  /**
+   * @since 3.11.0
+   * @experimental
+   * @category Fiber
+   */
+  export interface Variance<out A, out E = never> {
+    readonly _A: Covariant<A>
+    readonly _E: Covariant<E>
+  }
+}
+
+const fiberVariance = {
+  _A: identity,
+  _E: identity
+}
+
+class FiberImpl<in out A = any, in out E = any> implements Fiber<A, E> {
+  readonly [FiberTypeId]: Fiber.Variance<A, E>
+
+  readonly _stack: Array<Primitive> = []
+  readonly _observers: Array<(exit: MicroExit<A, E>) => void> = []
+  _exit: MicroExit<A, E> | undefined
+  public _children: Set<FiberImpl<any, any>> | undefined
+
+  public currentOpCount = 0
+
+  constructor(
+    public context: Context.Context<never>,
+    public interruptible = true
+  ) {
+    this[FiberTypeId] = fiberVariance
+  }
+
+  getRef<I, A>(ref: Context.Reference<I, A>): A {
+    return InternalContext.unsafeGetReference(this.context, ref)
+  }
+
+  addObserver(cb: (exit: MicroExit<A, E>) => void): () => void {
+    if (this._exit) {
+      cb(this._exit)
+      return constVoid
+    }
+    this._observers.push(cb)
+    return () => {
+      const index = this._observers.indexOf(cb)
+      if (index >= 0) {
+        this._observers.splice(index, 1)
+      }
+    }
+  }
+
+  _interrupted = false
+  unsafeInterrupt(): void {
+    if (this._exit) {
+      return
+    }
+    this._interrupted = true
+    if (this.interruptible) {
+      this.evaluate(exitInterrupt as any)
+    }
+  }
+
+  unsafePoll(): MicroExit<A, E> | undefined {
+    return this._exit
+  }
+
+  evaluate(effect: Primitive): void {
+    if (this._exit) {
+      return
+    } else if (this._yielded !== undefined) {
+      const yielded = this._yielded as () => void
+      this._yielded = undefined
+      yielded()
+    }
+    const exit = this.runLoop(effect)
+    if (exit === Yield) {
+      return
+    }
+
+    // the interruptChildren middlware is added in Micro.fork, so it can be
+    // tree-shaken if not used
+    const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this)
+    if (interruptChildren !== undefined) {
+      return this.evaluate(flatMap(interruptChildren, () => exit) as any)
+    }
+
+    this._exit = exit
+    for (let i = 0; i < this._observers.length; i++) {
+      this._observers[i](exit)
+    }
+    this._observers.length = 0
+  }
+
+  runLoop(effect: Primitive): MicroExit<A, E> | Yield {
+    let yielding = false
+    let current: Primitive | Yield = effect
+    this.currentOpCount = 0
+    try {
+      while (true) {
+        this.currentOpCount++
+        if (!yielding && this.getRef(CurrentScheduler).shouldYield(this as any)) {
+          yielding = true
+          const prev = current
+          current = flatMap(yieldNow, () => prev as any) as any
+        }
+        current = (current as any)[evaluate](this)
+        if (current === Yield) {
+          const yielded = this._yielded!
+          if (MicroExitTypeId in yielded) {
+            this._yielded = undefined
+            return yielded
+          }
+          return Yield
+        }
+      }
+    } catch (error) {
+      if (!hasProperty(current, evaluate)) {
+        return exitDie(`Micro/Fiber.runLoop: Not a valid effect: ${String(current)}`)
+      }
+      return exitDie(error)
+    }
+  }
+
+  getCont<S extends successCont | failureCont>(
+    symbol: S
+  ): Primitive & Record<S, (value: any, fiber: FiberImpl) => Primitive> | undefined {
+    while (true) {
+      const op = this._stack.pop()
+      if (!op) return undefined
+      const cont = op[ensureCont] && op[ensureCont](this)
+      if (cont) return { [symbol]: cont } as any
+      if (op[symbol]) return op as any
+    }
+  }
+
+  // cancel the yielded operation, or for the yielded exit value
+  _yielded: MicroExit<any, any> | (() => void) | undefined = undefined
+  yieldWith(value: MicroExit<any, any> | (() => void)): Yield {
+    this._yielded = value
+    return Yield
+  }
+
+  children(): Set<Fiber<any, any>> {
+    return this._children ??= new Set()
+  }
+}
+
+const fiberMiddleware = globalValue("effect/Micro/fiberMiddleware", () => ({
+  interruptChildren: undefined as ((fiber: FiberImpl) => Micro<void> | undefined) | undefined
+}))
+
+const fiberInterruptChildren = (fiber: FiberImpl) => {
+  if (fiber._children === undefined || fiber._children.size === 0) {
+    return undefined
+  }
+  return fiberInterruptAll(fiber._children)
+}
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export const exitDie = (defect: unknown): MicroExit<never> => Either.left(causeDie(defect))
+export const fiberAwait = <A, E>(self: Fiber<A, E>): Micro<MicroExit<A, E>> =>
+  async((resume) => sync(self.addObserver((exit) => resume(succeed(exit)))))
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E> = Either.left
+export const fiberInterrupt = <A, E>(self: Fiber<A, E>): Micro<void> =>
+  suspend(() => {
+    self.unsafeInterrupt()
+    return asVoid(fiberAwait(self))
+  })
 
 /**
- * @since 3.4.6
+ * @since 3.11.0
  * @experimental
- * @category MicroExit
+ * @category Fiber
  */
-export const exitIsSuccess: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Success<A, E> = Either.isRight
+export const fiberInterruptAll = <A extends Iterable<Fiber<any, any>>>(fibers: A): Micro<void> =>
+  suspend(() => {
+    for (const fiber of fibers) fiber.unsafeInterrupt()
+    const iter = fibers[Symbol.iterator]()
+    const wait: Micro<void> = suspend(() => {
+      let result = iter.next()
+      while (!result.done) {
+        if (result.value.unsafePoll()) {
+          result = iter.next()
+          continue
+        }
+        const fiber = result.value
+        return async((resume) => {
+          fiber.addObserver((_) => {
+            resume(wait)
+          })
+        })
+      }
+      return exitVoid
+    })
+    return wait
+  })
+
+const identifier = Symbol.for("effect/Micro/identifier")
+type identifier = typeof identifier
+
+const args = Symbol.for("effect/Micro/args")
+type args = typeof args
+
+const evaluate = Symbol.for("effect/Micro/evaluate")
+type evaluate = typeof evaluate
+
+const successCont = Symbol.for("effect/Micro/successCont")
+type successCont = typeof successCont
+
+const failureCont = Symbol.for("effect/Micro/failureCont")
+type failureCont = typeof failureCont
+
+const ensureCont = Symbol.for("effect/Micro/ensureCont")
+type ensureCont = typeof ensureCont
+
+const Yield = Symbol.for("effect/Micro/Yield")
+type Yield = typeof Yield
+
+interface Primitive {
+  readonly [identifier]: string
+  readonly [successCont]: ((value: unknown, fiber: FiberImpl) => Primitive | Yield) | undefined
+  readonly [failureCont]:
+    | ((cause: MicroCause<unknown>, fiber: FiberImpl) => Primitive | Yield)
+    | undefined
+  readonly [ensureCont]:
+    | ((fiber: FiberImpl) =>
+      | ((value: unknown, fiber: FiberImpl) => Primitive | Yield)
+      | undefined)
+    | undefined
+  [evaluate](fiber: FiberImpl): Primitive | Yield
+}
+
+const microVariance = {
+  _A: identity,
+  _E: identity,
+  _R: identity
+}
+
+const MicroProto = {
+  ...Effectable.EffectPrototype,
+  _op: "Micro",
+  [TypeId]: microVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this)) as any
+  },
+  toJSON(this: Primitive) {
+    return {
+      _id: "effect/Micro",
+      op: this[identifier],
+      ...(args in this ? { args: this[args] } : undefined)
+    }
+  },
+  toString() {
+    return format(this)
+  },
+  [NodeInspectSymbol]() {
+    return format(this)
+  }
+}
+
+function defaultEvaluate(_fiber: FiberImpl): Primitive | Yield {
+  return exitDie(`Micro.evaluate: Not implemented`) as any
+}
+
+const makePrimitiveProto = <Op extends string>(options: {
+  readonly op: Op
+  readonly eval?: (fiber: FiberImpl) => Primitive | Micro<any, any, any> | Yield
+  readonly contA?: (this: Primitive, value: any, fiber: FiberImpl) => Primitive | Micro<any, any, any> | Yield
+  readonly contE?: (
+    this: Primitive,
+    cause: MicroCause<any>,
+    fiber: FiberImpl
+  ) => Primitive | Micro<any, any, any> | Yield
+  readonly ensure?: (this: Primitive, fiber: FiberImpl) => void | ((value: any, fiber: FiberImpl) => void)
+}): Primitive => ({
+  ...MicroProto,
+  [identifier]: options.op,
+  [evaluate]: options.eval ?? defaultEvaluate,
+  [successCont]: options.contA,
+  [failureCont]: options.contE,
+  [ensureCont]: options.ensure
+} as any)
+
+const makePrimitive = <Fn extends (...args: Array<any>) => any, Single extends boolean = true>(options: {
+  readonly op: string
+  readonly single?: Single
+  readonly eval?: (
+    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
+    fiber: FiberImpl
+  ) => Primitive | Micro<any, any, any> | Yield
+  readonly contA?: (
+    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
+    value: any,
+    fiber: FiberImpl
+  ) => Primitive | Micro<any, any, any> | Yield
+  readonly contE?: (
+    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
+    cause: MicroCause<any>,
+    fiber: FiberImpl
+  ) => Primitive | Micro<any, any, any> | Yield
+  readonly ensure?: (
+    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
+    fiber: FiberImpl
+  ) => void | ((value: any, fiber: FiberImpl) => void)
+}): Fn => {
+  const Proto = makePrimitiveProto(options as any)
+  return function() {
+    const self = Object.create(Proto)
+    self[args] = options.single === false ? arguments : arguments[0]
+    return self
+  } as Fn
+}
+
+const makeExit = <Fn extends (...args: Array<any>) => any, Prop extends string>(options: {
+  readonly op: "Success" | "Failure"
+  readonly prop: Prop
+  readonly eval: (
+    this:
+      & MicroExit<unknown, unknown>
+      & { [args]: Parameters<Fn>[0] },
+    fiber: FiberImpl<unknown, unknown>
+  ) => Primitive | Yield
+}): Fn => {
+  const Proto = {
+    ...makePrimitiveProto(options),
+    [MicroExitTypeId]: MicroExitTypeId,
+    _tag: options.op,
+    get [options.prop](): any {
+      return (this as any)[args]
+    },
+    toJSON(this: any) {
+      return {
+        _id: "effect/Micro/Exit",
+        _tag: options.op,
+        [options.prop]: this[args]
+      }
+    },
+    [Equal.symbol](this: any, that: any): boolean {
+      return isMicroExit(that) && that._tag === options.op &&
+        Equal.equals(this[args], (that as any)[args])
+    },
+    [Hash.symbol](this: any): number {
+      return Hash.cached(this, Hash.combine(Hash.string(options.op))(Hash.hash(this[args])))
+    }
+  }
+  return function(value: unknown) {
+    const self = Object.create(Proto)
+    self[args] = value
+    self[successCont] = undefined
+    self[failureCont] = undefined
+    self[ensureCont] = undefined
+    return self
+  } as Fn
+}
 
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will succeed with the specified constant value.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export const exitIsFailure: <A, E>(self: MicroExit<A, E>) => self is MicroExit.Failure<A, E> = Either.isLeft
+export const succeed: <A>(value: A) => Micro<A> = makeExit({
+  op: "Success",
+  prop: "value",
+  eval(fiber) {
+    const cont = fiber.getCont(successCont)
+    return cont ? cont[successCont](this[args], fiber) : fiber.yieldWith(this)
+  }
+})
 
 /**
+ * Creates a `Micro` effect that will fail with the specified `MicroCause`.
+ *
  * @since 3.4.6
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export const exitIsInterrupt = <A, E>(self: MicroExit<A, E>): self is Either.Left<MicroCause.Interrupt, A> =>
-  exitIsFailure(self) && self.left._tag === "Interrupt"
+export const failCause: <E>(cause: MicroCause<E>) => Micro<never, E> = makeExit({
+  op: "Failure",
+  prop: "cause",
+  eval(fiber) {
+    let cont = fiber.getCont(failureCont)
+    while (causeIsInterrupt(this[args]) && cont && fiber.interruptible) {
+      cont = fiber.getCont(failureCont)
+    }
+    return cont ? cont[failureCont](this[args], fiber) : fiber.yieldWith(this)
+  }
+})
 
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will fail with the specified error.
+ *
+ * This will result in a `CauseFail`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export const exitIsFail = <A, E>(self: MicroExit<A, E>): self is Either.Left<MicroCause.Fail<E>, A> =>
-  exitIsFailure(self) && self.left._tag === "Fail"
+export const fail = <E>(error: E): Micro<never, E> => failCause(causeFail(error))
 
 /**
- * @since 3.4.6
+ * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ *
+ * If the evaluation of the value throws an error, the effect will fail with
+ * `CauseDie`.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export const exitIsDie = <A, E>(self: MicroExit<A, E>): self is Either.Left<MicroCause.Die, A> =>
-  exitIsFailure(self) && self.left._tag === "Die"
+export const sync: <A>(evaluate: LazyArg<A>) => Micro<A> = makePrimitive({
+  op: "Sync",
+  eval(fiber): Primitive | Yield {
+    const value = this[args]()
+    const cont = fiber.getCont(successCont)
+    return cont ? cont[successCont](value, fiber) : fiber.yieldWith(exitSucceed(value))
+  }
+})
 
 /**
- * @since 3.4.6
+ * Lazily creates a `Micro` effect from the given side-effect.
+ *
+ * @since 3.4.0
  * @experimental
- * @category MicroExit
+ * @category constructors
  */
-export const exitVoid: MicroExit<void> = exitSucceed(void 0)
-
-// ----------------------------------------------------------------------------
-// env
-// ----------------------------------------------------------------------------
+export const suspend: <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>) => Micro<A, E, R> = makePrimitive({
+  op: "Suspend",
+  eval(_fiber) {
+    return this[args]()
+  }
+})
 
 /**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * scheduler tick.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const EnvTypeId = Symbol.for("effect/Micro/Env")
+export const yieldNowWith: (priority?: number) => Micro<void> = makePrimitive({
+  op: "Yield",
+  eval(fiber) {
+    let resumed = false
+    fiber.getRef(CurrentScheduler).scheduleTask(() => {
+      if (resumed) return
+      fiber.evaluate(exitVoid as any)
+    }, this[args] ?? 0)
+    return fiber.yieldWith(() => {
+      resumed = true
+    })
+  }
+})
 
 /**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * scheduler tick.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export type EnvTypeId = typeof EnvTypeId
+export const yieldNow: Micro<void> = yieldNowWith(0)
 
 /**
- * @since 3.4.0
+ * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ *
+ * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export interface Env<R> extends Pipeable {
-  readonly [EnvTypeId]: {
-    _R: Covariant<R>
-  }
-  readonly refs: ReadonlyRecord<string, unknown>
-}
-
-const EnvProto = {
-  [EnvTypeId]: {
-    _R: identity
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
+export const succeedSome = <A>(a: A): Micro<Option.Option<A>> => succeed(Option.some(a))
 
 /**
+ * Creates a `Micro` effect that will succeed with `Option.None`.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const envMake = <R = never>(
-  refs: Record<string, unknown>
-): Env<R> => {
-  const self = Object.create(EnvProto)
-  self.refs = refs
-  return self
-}
+export const succeedNone: Micro<Option.Option<never>> = succeed(Option.none())
 
 /**
+ * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const envUnsafeMakeEmpty = (): Env<never> => {
-  const controller = new AbortController()
-  const refs = Object.create(null)
-  refs[currentAbortController.key] = controller
-  refs[currentAbortSignal.key] = controller.signal
-  refs[currentScheduler.key] = new MicroSchedulerDefault()
-  return envMake(refs)
-}
+export const failCauseSync = <E>(evaluate: LazyArg<MicroCause<E>>): Micro<never, E> =>
+  suspend(() => failCause(evaluate()))
 
 /**
+ * Creates a `Micro` effect that will die with the specified error.
+ *
+ * This will result in a `CauseDie`, where the error is not tracked at
+ * the type level.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const envGet: {
-  /**
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <A>(ref: EnvRef<A>): <R>(self: Env<R>) => A
-  /**
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <A, R>(self: Env<R>, ref: EnvRef<A>): A
-} = dual(2, <R, A>(self: Env<R>, ref: EnvRef<A>): A => ref.key in self.refs ? (self.refs[ref.key] as A) : ref.initial)
+export const die = (defect: unknown): Micro<never> => exitDie(defect)
+
+/**
+ * Creates a `Micro` effect that will fail with the lazily evaluated error.
+ *
+ * This will result in a `CauseFail`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.6
+ * @experimental
+ * @category constructors
+ */
+export const failSync = <E>(error: LazyArg<E>): Micro<never, E> => suspend(() => fail(error()))
 
 /**
+ * Converts an `Option` into a `Micro` effect, that will fail with
+ * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the
+ * value of the option.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const envSet: {
-  /**
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <A>(ref: EnvRef<A>, value: A): <R>(self: Env<R>) => Env<R>
-  /**
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <A, R>(self: Env<R>, ref: EnvRef<A>, value: A): Env<R>
-} = dual(3, <R, A>(self: Env<R>, ref: EnvRef<A>, value: A): Env<R> => {
-  const refs = Object.assign(Object.create(null), self.refs)
-  refs[ref.key] = value
-  return envMake(refs)
-})
+export const fromOption = <A>(option: Option.Option<A>): Micro<A, NoSuchElementException> =>
+  option._tag === "Some" ? succeed(option.value) : fail(new NoSuchElementException({}))
 
 /**
+ * Converts an `Either` into a `Micro` effect, that will fail with the left side
+ * of the either if it is a `Left`. Otherwise, it will succeed with the right
+ * side of the either.
+ *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const envMutate: {
+export const fromEither = <R, L>(either: Either.Either<R, L>): Micro<R, L> =>
+  either._tag === "Right" ? succeed(either.right) : fail(either.left)
+
+const void_: Micro<void> = succeed(void 0)
+export {
   /**
+   * A `Micro` effect that will succeed with `void` (`undefined`).
+   *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category constructors
    */
-  (f: (map: Record<string, unknown>) => void): <R>(self: Env<R>) => Env<R>
+  void_ as void
+}
+
+const try_ = <A, E>(options: {
+  try: LazyArg<A>
+  catch: (error: unknown) => E
+}): Micro<A, E> =>
+  suspend(() => {
+    try {
+      return succeed(options.try())
+    } catch (err) {
+      return fail(options.catch(err))
+    }
+  })
+export {
   /**
+   * The `Micro` equivalent of a try / catch block, which allows you to map
+   * thrown errors to a specific error type.
+   *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category constructors
+   * @example
+   * ```ts
+   * import { Micro } from "effect"
+   *
+   * Micro.try({
+   *   try: () => throw new Error("boom"),
+   *   catch: (cause) => new Error("caught", { cause })
+   * })
+   * ```
    */
-  <R>(self: Env<R>, f: (map: Record<string, unknown>) => void): Env<R>
-} = dual(
-  2,
-  <R>(self: Env<R>, f: (map: Record<string, unknown>) => ReadonlyRecord<string, unknown>): Env<R> =>
-    envMake(f(Object.assign(Object.create(null), self.refs)))
-)
+  try_ as try
+}
 
 /**
- * Access the given `Context.Tag` from the environment.
+ * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
+ * `CauseDie`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const service = <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I> =>
-  make(function(env, onExit) {
-    onExit(exitSucceed(Context.get(envGet(env, currentContext) as Context.Context<I>, tag as any) as S))
-  })
+export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Micro<A> =>
+  asyncOptions<A>(function(resume, signal) {
+    evaluate(signal!).then(
+      (a) => resume(succeed(a)),
+      (e) => resume(die(e))
+    )
+  }, evaluate.length !== 0)
 
 /**
- * Access the given `Context.Tag` from the environment, without tracking the
- * dependency at the type level.
+ * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
+ * converted into a specific error type.
  *
- * It will return an `Option` of the service, depending on whether it is
- * available in the environment or not.
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ * @example
+ * ```ts
+ * import { Micro } from "effect"
+ *
+ * Micro.tryPromise({
+ *   try: () => Promise.resolve("success"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ * ```
+ */
+export const tryPromise = <A, E>(options: {
+  readonly try: (signal: AbortSignal) => PromiseLike<A>
+  readonly catch: (error: unknown) => E
+}): Micro<A, E> =>
+  asyncOptions<A, E>(function(resume, signal) {
+    try {
+      options.try(signal!).then(
+        (a) => resume(succeed(a)),
+        (e) => resume(fail(options.catch(e)))
+      )
+    } catch (err) {
+      resume(fail(options.catch(err)))
+    }
+  }, options.try.length !== 0)
+
+/**
+ * Create a `Micro` effect using the current `Fiber`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const serviceOption = <I, S>(tag: Context.Tag<I, S>): Micro<Option.Option<S>> =>
-  make(function(env, onExit) {
-    onExit(exitSucceed(Context.getOption(envGet(env, currentContext) as Context.Context<I>, tag)))
-  })
+export const withFiber: <A, E = never, R = never>(
+  evaluate: (fiber: FiberImpl<A, E>) => Micro<A, E, R>
+) => Micro<A, E, R> = makePrimitive({
+  op: "WithFiber",
+  eval(fiber) {
+    return this[args](fiber)
+  }
+})
 
 /**
- * Retrieve the current value of the given `EnvRef`.
+ * Flush any yielded effects that are waiting to be executed.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const getEnvRef = <A>(envRef: EnvRef<A>): Micro<A> =>
-  make((env, onExit) => onExit(Either.right(envGet(env, envRef))))
+export const yieldFlush: Micro<void> = withFiber((fiber) => {
+  fiber.getRef(CurrentScheduler).flush()
+  return exitVoid
+})
+
+const asyncOptions: <A, E = never, R = never>(
+  register: (
+    resume: (effect: Micro<A, E, R>) => void,
+    signal?: AbortSignal
+  ) => void | Micro<void, never, R>,
+  withSignal: boolean
+) => Micro<A, E, R> = makePrimitive({
+  op: "Async",
+  single: false,
+  eval(fiber) {
+    const register = this[args][0]
+    let resumed = false
+    let yielded: boolean | Primitive = false
+    const controller = this[args][1] ? new AbortController() : undefined
+    const onCancel = register((effect) => {
+      if (resumed) return
+      resumed = true
+      if (yielded) {
+        fiber.evaluate(effect as any)
+      } else {
+        yielded = effect as any
+      }
+    }, controller?.signal)
+    if (yielded !== false) return yielded
+    yielded = true
+    fiber._yielded = () => {
+      resumed = true
+    }
+    if (controller === undefined && onCancel === undefined) {
+      return Yield
+    }
+    fiber._stack.push(asyncFinalizer(() => {
+      resumed = true
+      controller?.abort()
+      return onCancel ?? exitVoid
+    }))
+    return Yield
+  }
+})
+const asyncFinalizer: (onInterrupt: () => Micro<void, any, any>) => Primitive = makePrimitive({
+  op: "AsyncFinalizer",
+  ensure(fiber) {
+    if (fiber.interruptible) {
+      fiber.interruptible = false
+      fiber._stack.push(setInterruptible(true))
+    }
+  },
+  contE(cause, _fiber) {
+    return causeIsInterrupt(cause)
+      ? flatMap(this[args](), () => failCause(cause))
+      : failCause(cause)
+  }
+})
 
 /**
- * Set the value of the given `EnvRef` for the duration of the effect.
+ * Create a `Micro` effect from an asynchronous computation.
+ *
+ * You can return a cleanup effect that will be run when the effect is aborted.
+ * It is also passed an `AbortSignal` that is triggered when the effect is
+ * aborted.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const locally: {
-  /**
-   * Set the value of the given `EnvRef` for the duration of the effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <A>(fiberRef: EnvRef<A>, value: A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>
-  /**
-   * Set the value of the given `EnvRef` for the duration of the effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category environment
-   */
-  <XA, E, R, A>(self: Micro<XA, E, R>, fiberRef: EnvRef<A>, value: A): Micro<XA, E, R>
-} = dual(
-  3,
-  <XA, E, R, A>(self: Micro<XA, E, R>, fiberRef: EnvRef<A>, value: A): Micro<XA, E, R> =>
-    make((env, onExit) => self[runSymbol](envSet(env, fiberRef, value), onExit))
-)
+export const async = <A, E = never, R = never>(
+  register: (
+    resume: (effect: Micro<A, E, R>) => void,
+    signal: AbortSignal
+  ) => void | Micro<void, never, R>
+): Micro<A, E, R> => asyncOptions(register as any, register.length >= 2)
 
 /**
- * Access the current `Context` from the environment.
+ * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
+ * the Javascript runtime from exiting.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category constructors
  */
-export const context = <R>(): Micro<Context.Context<R>> => getEnvRef(currentContext) as any
+export const never: Micro<never> = async<never>(function() {
+  const interval = setInterval(constVoid, 2147483646)
+  return sync(() => clearInterval(interval))
+})
 
 /**
- * Merge the given `Context` with the current context.
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export const gen = <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(
+  ...args:
+    | [self: Self, body: (this: Self) => Generator<Eff, AEff, never>]
+    | [body: () => Generator<Eff, AEff, never>]
+): Micro<
+  AEff,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never
+> => suspend(() => fromIterator(args.length === 1 ? args[0]() : args[1].call(args[0]) as any))
+
+const fromIterator: (
+  iterator: Iterator<any, YieldWrap<Micro<any, any, any>>>
+) => Micro<any, any, any> = makePrimitive({
+  op: "Iterator",
+  contA(value, fiber) {
+    const state = this[args].next(value)
+    if (state.done) return succeed(state.value)
+    fiber._stack.push(this)
+    return yieldWrapGet(state.value)
+  },
+  eval(this: any, fiber: FiberImpl) {
+    return this[successCont](undefined, fiber)
+  }
+})
+
+// ----------------------------------------------------------------------------
+// mapping & sequencing
+// ----------------------------------------------------------------------------
+
+/**
+ * Create a `Micro` effect that will replace the success value of the given
+ * effect.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export const provideContext: {
+export const as: {
+  // ----------------------------------------------------------------------------
+  // mapping & sequencing
+  // ----------------------------------------------------------------------------
+
   /**
-   * Merge the given `Context` with the current context.
+   * Create a `Micro` effect that will replace the success value of the given
+   * effect.
    *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>
-  /**
-   * Merge the given `Context` with the current context.
-   *
+  <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
+  // ----------------------------------------------------------------------------
+  // mapping & sequencing
+  // ----------------------------------------------------------------------------
+
+  /**
+   * Create a `Micro` effect that will replace the success value of the given
+   * effect.
+   *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>
-} = dual(
-  2,
-  <A, E, R, XR>(self: Micro<A, E, R>, provided: Context.Context<XR>): Micro<A, E, Exclude<R, XR>> =>
-    make(function(env, onExit) {
-      const context = envGet(env, currentContext)
-      const nextEnv = envSet(env, currentContext, Context.merge(context, provided))
-      self[runSymbol](nextEnv, onExit)
-    })
-)
+  <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>
+} = dual(2, <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R> => map(self, (_) => value))
 
 /**
- * Add the provided service to the current context.
+ * Wrap the success value of this `Micro` effect in an `Option.Some`.
  *
  * @since 3.4.0
  * @experimental
- * @category environment
+ * @category mapping & sequencing
  */
-export const provideService: {
+export const asSome = <A, E, R>(self: Micro<A, E, R>): Micro<Option.Option<A>, E, R> => map(self, Option.some)
+
+/**
+ * Swap the error and success types of the `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export const flip = <A, E, R>(self: Micro<A, E, R>): Micro<E, A, R> =>
+  matchEffect(self, {
+    onFailure: succeed,
+    onSuccess: fail
+  })
+
+/**
+ * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+ * a single api.
+ *
+ * It also allows you to pass in a `Micro` effect directly, which will be
+ * executed after the current effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export const andThen: {
   /**
-   * Add the provided service to the current context.
+   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+   * a single api.
+   *
+   * It also allows you to pass in a `Micro` effect directly, which will be
+   * executed after the current effect.
    *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>
+  <A, X>(f: (a: A) => X): <E, R>(
+    self: Micro<A, E, R>
+  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+    : Micro<X, E, R>
   /**
-   * Add the provided service to the current context.
+   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+   * a single api.
+   *
+   * It also allows you to pass in a `Micro` effect directly, which will be
+   * executed after the current effect.
    *
    * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>
-} = dual(
-  3,
-  <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>> =>
-    make(function(env, onExit) {
-      const context = envGet(env, currentContext)
-      const nextEnv = envSet(env, currentContext, Context.add(context, tag, service))
-      self[runSymbol](nextEnv, onExit)
-    })
-)
-
-/**
- * Create a service using the provided `Micro` effect, and add it to the
- * current context.
- *
- * @since 3.4.6
- * @experimental
- * @category environment
- */
-export const provideServiceEffect: {
+  <X>(f: NotFunction<X>): <A, E, R>(
+    self: Micro<A, E, R>
+  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+    : Micro<X, E, R>
   /**
-   * Create a service using the provided `Micro` effect, and add it to the
-   * current context.
+   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+   * a single api.
    *
-   * @since 3.4.6
+   * It also allows you to pass in a `Micro` effect directly, which will be
+   * executed after the current effect.
+   *
+   * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
+  <A, E, R, X>(
+    self: Micro<A, E, R>,
+    f: (a: A) => X
+  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+    : Micro<X, E, R>
   /**
-   * Create a service using the provided `Micro` effect, and add it to the
-   * current context.
+   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+   * a single api.
    *
-   * @since 3.4.6
+   * It also allows you to pass in a `Micro` effect directly, which will be
+   * executed after the current effect.
+   *
+   * @since 3.4.0
    * @experimental
-   * @category environment
+   * @category mapping & sequencing
    */
-  <A, E, R, I, S, E2, R2>(
+  <A, E, R, X>(
     self: Micro<A, E, R>,
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): Micro<A, E | E2, Exclude<R, I> | R2>
+    f: NotFunction<X>
+  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
+    : Micro<X, E, R>
 } = dual(
-  3,
-  <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> => flatMap(acquire, (service) => provideService(self, tag, service))
+  2,
+  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: any): Micro<B, E | E2, R | R2> =>
+    flatMap(self, (a) => {
+      const value = isMicro(f) ? f : typeof f === "function" ? f(a) : f
+      return isMicro(value) ? value : succeed(value)
+    })
 )
 
-// ----------------------------------------------------------------------------
-// scheduler
-// ----------------------------------------------------------------------------
-
 /**
- * @since 3.5.9
- * @experimental
- * @category scheduler
- */
-export interface MicroScheduler {
-  readonly scheduleTask: (task: () => void, priority: number) => void
-  readonly shouldYield: (env: Env<unknown>) => boolean
-  readonly flush: () => void
-}
-
-const setImmediate = "setImmediate" in globalThis ? globalThis.setImmediate : (f: () => void) => setTimeout(f, 0)
-
-/**
- * @since 3.5.9
+ * Execute a side effect from the success value of the `Micro` effect.
+ *
+ * It is similar to the `andThen` api, but the success value is ignored.
+ *
+ * @since 3.4.0
  * @experimental
- * @category scheduler
+ * @category mapping & sequencing
  */
-export class MicroSchedulerDefault implements MicroScheduler {
-  private tasks: Array<() => void> = []
-  private running = false
-
-  /**
-   * @since 3.5.9
-   */
-  scheduleTask(task: () => void, _priority: number) {
-    this.tasks.push(task)
-    if (!this.running) {
-      this.running = true
-      setImmediate(this.afterScheduled)
-    }
-  }
-
-  /**
-   * @since 3.5.9
-   */
-  afterScheduled = () => {
-    this.running = false
-    this.runTasks()
-  }
-
-  /**
-   * @since 3.5.9
-   */
-  runTasks() {
-    const tasks = this.tasks
-    this.tasks = []
-    for (let i = 0, len = tasks.length; i < len; i++) {
-      tasks[i]()
-    }
-  }
-
+export const tap: {
   /**
-   * @since 3.5.9
+   * Execute a side effect from the success value of the `Micro` effect.
+   *
+   * It is similar to the `andThen` api, but the success value is ignored.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
    */
-  shouldYield(_env: Env<unknown>) {
-    return false
-  }
-
+  <A, X>(f: (a: NoInfer<A>) => X): <E, R>(
+    self: Micro<A, E, R>
+  ) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+    : Micro<A, E, R>
   /**
-   * @since 3.5.9
+   * Execute a side effect from the success value of the `Micro` effect.
+   *
+   * It is similar to the `andThen` api, but the success value is ignored.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
    */
-  flush() {
-    while (this.tasks.length > 0) {
-      this.runTasks()
-    }
-  }
-}
-
-// ========================================================================
-// Env refs
-// ========================================================================
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const EnvRefTypeId: unique symbol = Symbol.for("effect/Micro/EnvRef")
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export type EnvRefTypeId = typeof EnvRefTypeId
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export interface EnvRef<A> extends Micro<A> {
-  readonly [EnvRefTypeId]: EnvRefTypeId
-  readonly key: string
-  readonly initial: A
-
-  [Unify.typeSymbol]?: unknown
-  [Unify.unifySymbol]?: EnvRefUnify<this>
-  [Unify.ignoreSymbol]?: EnvRefUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface EnvRefUnify<A extends { [Unify.typeSymbol]?: any }> extends MicroUnify<A> {
-  EnvRef?: () => A[Unify.typeSymbol] extends EnvRef<infer A0> | infer _ ? EnvRef<A0> : never
-}
-
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface EnvRefUnifyIgnore extends MicroUnifyIgnore {
-  Micro?: true
-}
-
-const EnvRefProto: ThisType<EnvRef<any>> = {
-  ...MicroProto,
-  [EnvRefTypeId]: EnvRefTypeId,
-  [runSymbol](env: Env<any>, onExit: (exit: MicroExit<any, any>) => void) {
-    getEnvRef(this)[runSymbol](env, onExit)
-  }
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const envRefMake = <A>(key: string, initial: LazyArg<A>): EnvRef<A> =>
-  globalValue(key, () => {
-    const self = Object.create(EnvRefProto)
-    self.key = key
-    self.initial = initial()
-    return self
-  })
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentAbortController: EnvRef<AbortController> = envRefMake(
-  "effect/Micro/currentAbortController",
-  () => undefined as any
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentAbortSignal: EnvRef<AbortSignal> = envRefMake(
-  "effect/Micro/currentAbortSignal",
-  () => undefined as any
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentContext: EnvRef<Context.Context<never>> = envRefMake(
-  "effect/Micro/currentContext",
-  () => Context.empty()
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentConcurrency: EnvRef<"unbounded" | number> = envRefMake(
-  "effect/Micro/currentConcurrency",
-  () => "unbounded"
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentMaxDepthBeforeYield: EnvRef<number> = envRefMake(
-  "effect/Micro/currentMaxDepthBeforeYield",
-  () => 2048
-)
-
-const currentInterruptible: EnvRef<boolean> = envRefMake(
-  "effect/Micro/currentInterruptible",
-  () => true
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const currentScheduler: EnvRef<MicroScheduler> = envRefMake(
-  "effect/Micro/currentScheduler",
-  () => new MicroSchedulerDefault()
-)
-
-/**
- * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
- * api to control the concurrency of that `Micro` when it is run.
- *
- * @since 3.4.0
- * @experimental
- * @category environment refs
- * @example
- * ```ts
- * import * as Micro from "effect/Micro"
- *
- * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
- *   concurrency: "inherit"
- * }).pipe(
- *   Micro.withConcurrency(2) // use a concurrency of 2
- * )
- * ```
- */
-export const withConcurrency: {
+  <X>(f: NotFunction<X>): <A, E, R>(
+    self: Micro<A, E, R>
+  ) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+    : Micro<A, E, R>
   /**
-   * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
-   * api to control the concurrency of that `Micro` when it is run.
+   * Execute a side effect from the success value of the `Micro` effect.
+   *
+   * It is similar to the `andThen` api, but the success value is ignored.
    *
    * @since 3.4.0
    * @experimental
-   * @category environment refs
-   * @example
-   * ```ts
-   * import * as Micro from "effect/Micro"
-   *
-   * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
-   *   concurrency: "inherit"
-   * }).pipe(
-   *   Micro.withConcurrency(2) // use a concurrency of 2
-   * )
-   * ```
+   * @category mapping & sequencing
    */
-  (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
+  <A, E, R, X>(
+    self: Micro<A, E, R>,
+    f: (a: NoInfer<A>) => X
+  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+    : Micro<A, E, R>
   /**
-   * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
-   * api to control the concurrency of that `Micro` when it is run.
+   * Execute a side effect from the success value of the `Micro` effect.
+   *
+   * It is similar to the `andThen` api, but the success value is ignored.
    *
    * @since 3.4.0
    * @experimental
-   * @category environment refs
-   * @example
-   * ```ts
-   * import * as Micro from "effect/Micro"
-   *
-   * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
-   *   concurrency: "inherit"
-   * }).pipe(
-   *   Micro.withConcurrency(2) // use a concurrency of 2
-   * )
-   * ```
+   * @category mapping & sequencing
    */
-  <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>
+  <A, E, R, X>(
+    self: Micro<A, E, R>,
+    f: NotFunction<X>
+  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
+    : Micro<A, E, R>
 } = dual(
   2,
-  <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R> =>
-    locally(self, currentConcurrency, concurrency)
+  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2> =>
+    flatMap(self, (a) => {
+      const value = isMicro(f) ? f : typeof f === "function" ? f(a) : f
+      return isMicro(value) ? as(value, a) : succeed(a)
+    })
 )
 
-// ----------------------------------------------------------------------------
-// constructors
-// ----------------------------------------------------------------------------
-
-const microDepthState = globalValue("effect/Micro/microDepthState", () => ({
-  depth: 0,
-  maxDepthBeforeYield: currentMaxDepthBeforeYield.initial
-}))
-
-const unsafeMake = <R, A, E>(
-  run: (env: Env<R>, onExit: (exit: MicroExit<A, E>) => void) => void
-): Micro<A, E, R> => {
-  const self = Object.create(MicroProto)
-  self[runSymbol] = run
-  return self
-}
-
-const unsafeMakeOptions = <R, A, E>(
-  run: (env: Env<R>, onExit: (exit: MicroExit<A, E>) => void) => void,
-  checkAbort: boolean
-): Micro<A, E, R> =>
-  unsafeMake(function execute(env, onExit) {
-    if (
-      checkAbort && env.refs[currentInterruptible.key] !== false &&
-      (env.refs[currentAbortSignal.key] as AbortSignal).aborted
-    ) {
-      return onExit(exitInterrupt)
-    }
-    microDepthState.depth++
-    if (microDepthState.depth === 1) {
-      microDepthState.maxDepthBeforeYield = envGet(env, currentMaxDepthBeforeYield)
-    }
-    const scheduler = env.refs[currentScheduler.key] as MicroScheduler
-    if (microDepthState.depth >= microDepthState.maxDepthBeforeYield || scheduler.shouldYield(env)) {
-      scheduler.scheduleTask(() => execute(env, onExit), 0)
-    } else {
-      try {
-        run(env, onExit)
-      } catch (err) {
-        onExit(exitDie(err))
-      }
-    }
-    microDepthState.depth--
-  })
-
 /**
- * A low-level constructor for creating a `Micro` effect. It takes a function
- * that receives an environment and a callback which should be called with the
- * result of the effect.
+ * Replace the success value of the `Micro` effect with `void`.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export const make = <R, A, E>(
-  run: (env: Env<R>, onExit: (exit: MicroExit<A, E>) => void) => void
-): Micro<A, E, R> => unsafeMakeOptions(run, true)
+export const asVoid = <A, E, R>(self: Micro<A, E, R>): Micro<void, E, R> => flatMap(self, (_) => exitVoid)
 
 /**
- * Converts a `MicroExit` into a `Micro` effect.
+ * Access the `MicroExit` of the given `Micro` effect.
  *
  * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export const fromExit = <A, E>(self: MicroExit<A, E>): Micro<A, E> =>
-  make(function(_env, onExit) {
-    onExit(self)
+export const exit = <A, E, R>(self: Micro<A, E, R>): Micro<MicroExit<A, E>, never, R> =>
+  matchCause(self, {
+    onFailure: exitFailCause,
+    onSuccess: exitSucceed
   })
 
 /**
- * Converts a lazy `MicroExit` into a `Micro` effect.
+ * Replace the error type of the given `Micro` with the full `MicroCause` object.
  *
- * @since 3.4.6
+ * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export const fromExitSync = <A, E>(self: LazyArg<MicroExit<A, E>>): Micro<A, E> =>
-  make(function(_env, onExit) {
-    onExit(self())
-  })
+export const sandbox = <A, E, R>(self: Micro<A, E, R>): Micro<A, MicroCause<E>, R> => catchAllCause(self, fail)
 
 /**
- * Creates a `Micro` effect that will succeed with the specified constant value.
+ * Returns an effect that races all the specified effects,
+ * yielding the value of the first effect to succeed with a value. Losers of
+ * the race will be interrupted immediately
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category sequencing
  */
-export const succeed = <A>(a: A): Micro<A> => fromExit(exitSucceed(a))
+export const raceAll = <Eff extends Micro<any, any, any>>(
+  all: Iterable<Eff>
+): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
+  withFiber((parent) =>
+    async((resume) => {
+      const effects = Arr.fromIterable(all)
+      const len = effects.length
+      let doneCount = 0
+      let done = false
+      const fibers = new Set<Fiber<any, any>>()
+      const causes: Array<MicroCause<any>> = []
+      const onExit = (exit: MicroExit<any, any>) => {
+        doneCount++
+        if (exit._tag === "Failure") {
+          causes.push(exit.cause)
+          if (doneCount >= len) {
+            resume(failCause(causes[0]))
+          }
+          return
+        }
+        done = true
+        resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit))
+      }
+
+      for (let i = 0; i < len; i++) {
+        if (done) break
+        const fiber = unsafeFork(parent, interruptible(effects[i]), true, true)
+        fibers.add(fiber)
+        fiber.addObserver((exit) => {
+          fibers.delete(fiber)
+          onExit(exit)
+        })
+      }
+
+      return fiberInterruptAll(fibers)
+    })
+  )
 
 /**
- * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ * Returns an effect that races all the specified effects,
+ * yielding the value of the first effect to succeed or fail. Losers of
+ * the race will be interrupted immediately
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category sequencing
  */
-export const succeedSome = <A>(a: A): Micro<Option.Option<A>> => succeed(Option.some(a))
+export const raceAllFirst = <Eff extends Micro<any, any, any>>(
+  all: Iterable<Eff>
+): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
+  withFiber((parent) =>
+    async((resume) => {
+      let done = false
+      const fibers = new Set<Fiber<any, any>>()
+      const onExit = (exit: MicroExit<any, any>) => {
+        done = true
+        resume(fibers.size === 0 ? exit : flatMap(fiberInterruptAll(fibers), () => exit))
+      }
+
+      for (const effect of all) {
+        if (done) break
+        const fiber = unsafeFork(parent, interruptible(effect), true, true)
+        fibers.add(fiber)
+        fiber.addObserver((exit) => {
+          fibers.delete(fiber)
+          onExit(exit)
+        })
+      }
+
+      return fiberInterruptAll(fibers)
+    })
+  )
 
 /**
- * Creates a `Micro` effect that will succeed with `Option.None`.
+ * Returns an effect that races two effects, yielding the value of the first
+ * effect to succeed. Losers of the race will be interrupted immediately
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category sequencing
  */
-export const succeedNone: Micro<Option.Option<never>> = succeed(Option.none())
+export const race: {
+  /**
+   * Returns an effect that races two effects, yielding the value of the first
+   * effect to succeed. Losers of the race will be interrupted immediately
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category sequencing
+   */
+  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
+  /**
+   * Returns an effect that races two effects, yielding the value of the first
+   * effect to succeed. Losers of the race will be interrupted immediately
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category sequencing
+   */
+  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2> =>
+    raceAll([self, that])
+)
 
 /**
- * Creates a `Micro` effect that will fail with the specified error.
+ * Returns an effect that races two effects, yielding the value of the first
+ * effect to succeed *or* fail. Losers of the race will be interrupted immediately
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * @since 3.4.0
+ * @experimental
+ * @category sequencing
+ */
+export const raceFirst: {
+  /**
+   * Returns an effect that races two effects, yielding the value of the first
+   * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category sequencing
+   */
+  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
+  /**
+   * Returns an effect that races two effects, yielding the value of the first
+   * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category sequencing
+   */
+  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2> =>
+    raceAllFirst([self, that])
+)
+
+/**
+ * Map the success value of this `Micro` effect to another `Micro` effect, then
+ * flatten the result.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export const fail = <E>(e: E): Micro<never, E> => fromExit(exitFail(e))
+export const flatMap: {
+  /**
+   * Map the success value of this `Micro` effect to another `Micro` effect, then
+   * flatten the result.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
+   */
+  <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>
+  /**
+   * Map the success value of this `Micro` effect to another `Micro` effect, then
+   * flatten the result.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
+   */
+  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Micro<A, E, R>,
+    f: (a: A) => Micro<B, E2, R2>
+  ): Micro<B, E | E2, R | R2> => {
+    const onSuccess = Object.create(OnSuccessProto)
+    onSuccess[args] = self
+    onSuccess[successCont] = f
+    return onSuccess
+  }
+)
+const OnSuccessProto = makePrimitiveProto({
+  op: "OnSuccess",
+  eval(this: any, fiber: FiberImpl): Primitive {
+    fiber._stack.push(this)
+    return this[args]
+  }
+})
+
+// ----------------------------------------------------------------------------
+// mapping & sequencing
+// ----------------------------------------------------------------------------
 
 /**
- * Creates a `Micro` effect that will fail with the lazily evaluated error.
+ * Flattens any nested `Micro` effects, merging the error and requirement types.
  *
- * This will result in a `CauseFail`, where the error is tracked at the
- * type level.
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export const flatten = <A, E, R, E2, R2>(
+  self: Micro<Micro<A, E, R>, E2, R2>
+): Micro<A, E | E2, R | R2> => flatMap(self, identity)
+
+/**
+ * Transforms the success value of the `Micro` effect with the specified
+ * function.
  *
  * @since 3.4.0
  * @experimental
- * @category constructors
+ * @category mapping & sequencing
  */
-export const failSync = <E>(e: LazyArg<E>): Micro<never, E> =>
-  make(function(_env, onExit) {
-    onExit(exitFail(e()))
-  })
+export const map: {
+  /**
+   * Transforms the success value of the `Micro` effect with the specified
+   * function.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
+   */
+  <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
+  /**
+   * Transforms the success value of the `Micro` effect with the specified
+   * function.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category mapping & sequencing
+   */
+  <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>
+} = dual(
+  2,
+  <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R> => flatMap(self, (a) => succeed(f(a)))
+)
+
+// ----------------------------------------------------------------------------
+// MicroExit
+// ----------------------------------------------------------------------------
 
 /**
- * Creates a `Micro` effect that will die with the specified error.
+ * The MicroExit type is a data type that represents the result of a Micro
+ * computation.
  *
- * This will result in a `CauseDie`, where the error is not tracked at
- * the type level.
+ * It uses the `Either` data type to represent the success and failure cases.
  *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
+ */
+export type MicroExit<A, E = never> =
+  | MicroExit.Success<A, E>
+  | MicroExit.Failure<A, E>
+
+/**
+ * @since 3.4.6
+ * @experimental
+ * @category MicroExit
  */
-export const die = (defect: unknown): Micro<never> => fromExit(exitDie(defect))
+export declare namespace MicroExit {
+  /**
+   * @since 3.4.6
+   * @experimental
+   * @category MicroExit
+   */
+  export interface Proto<out A, out E = never> extends Micro<A, E> {
+    readonly [MicroExitTypeId]: MicroExitTypeId
+  }
+
+  /**
+   * @since 3.4.6
+   * @experimental
+   * @category MicroExit
+   */
+  export interface Success<out A, out E> extends Proto<A, E> {
+    readonly _tag: "Success"
+    readonly value: A
+  }
+
+  /**
+   * @since 3.4.6
+   * @experimental
+   * @category MicroExit
+   */
+  export interface Failure<out A, out E> extends Proto<A, E> {
+    readonly _tag: "Failure"
+    readonly cause: MicroCause<E>
+  }
+}
 
 /**
- * Creates a `Micro` effect that will fail with the specified `MicroCause`.
- *
  * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const failCause = <E>(cause: MicroCause<E>): Micro<never, E> => fromExit(exitFailCause(cause))
+export const isMicroExit = (u: unknown): u is MicroExit<unknown, unknown> => hasProperty(u, MicroExitTypeId)
 
 /**
- * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`.
- *
  * @since 3.4.6
  * @experimental
- * @category constructors
- */
-export const failCauseSync = <E>(cause: LazyArg<MicroCause<E>>): Micro<never, E> =>
-  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
- * `CauseDie`.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const sync = <A>(evaluate: LazyArg<A>): Micro<A> =>
-  make(function(_env, onExit) {
-    onExit(exitSucceed(evaluate()))
-  })
+export const exitSucceed: <A>(a: A) => MicroExit<A, never> = succeed as any
 
 /**
- * Converts an `Option` into a `Micro` effect, that will fail with
- * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the
- * value of the option.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const fromOption = <A>(option: Option.Option<A>): Micro<A, NoSuchElementException> =>
-  make(function(_env, onExit) {
-    onExit(option._tag === "Some" ? exitSucceed(option.value) : exitFail(new NoSuchElementException({})))
-  })
+export const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E> = failCause as any
 
 /**
- * Converts an `Either` into a `Micro` effect, that will fail with the left side
- * of the either if it is a `Left`. Otherwise, it will succeed with the right
- * side of the either.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const fromEither = <R, L>(either: Either.Either<R, L>): Micro<R, L> =>
-  make(function(_env, onExit) {
-    onExit(either._tag === "Right" ? either as MicroExit<R, never> : exitFail(either.left))
-  })
+export const exitInterrupt: MicroExit<never> = exitFailCause(causeInterrupt())
 
 /**
- * Lazily creates a `Micro` effect from the given side-effect.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const suspend = <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>): Micro<A, E, R> =>
-  make(function(env, onExit) {
-    evaluate()[runSymbol](env, onExit)
-  })
-
-const void_: Micro<void> = succeed(void 0)
-export {
-  /**
-   * A `Micro` effect that will succeed with `void` (`undefined`).
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category constructors
-   */
-  void_ as void
-}
+export const exitFail = <E>(e: E): MicroExit<never, E> => exitFailCause(causeFail(e))
 
 /**
- * Create a `Micro` effect from an asynchronous computation.
- *
- * You can return a cleanup effect that will be run when the effect is aborted.
- * It is also passed an `AbortSignal` that is triggered when the effect is
- * aborted.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const async = <A, E = never, R = never>(
-  register: (resume: (effect: Micro<A, E, R>) => void, signal: AbortSignal) => void | Micro<void, never, R>
-): Micro<A, E, R> =>
-  make(function(env, onExit) {
-    let resumed = false
-    const controller = register.length > 1 ? new AbortController() : undefined
-    const signal = envGet(env, currentAbortSignal)
-    let cleanup: Micro<void, never, R> | void = undefined
-    function onAbort() {
-      if (cleanup) {
-        resume(uninterruptible(andThen(cleanup, fromExit(exitInterrupt))))
-      } else {
-        resume(fromExit(exitInterrupt))
-      }
-      if (controller !== undefined) {
-        controller.abort()
-      }
-    }
-    function resume(effect: Micro<A, E, R>) {
-      if (resumed) {
-        return
-      }
-      resumed = true
-      signal.removeEventListener("abort", onAbort)
-      effect[runSymbol](env, onExit)
-    }
-    cleanup = controller === undefined
-      ? (register as any)(resume)
-      : register(resume, controller.signal)
-    if (resumed) return
-    signal.addEventListener("abort", onAbort)
-  })
-
-const try_ = <A, E>(options: {
-  try: LazyArg<A>
-  catch: (error: unknown) => E
-}): Micro<A, E> =>
-  make(function(_env, onExit) {
-    try {
-      onExit(exitSucceed(options.try()))
-    } catch (err) {
-      onExit(exitFail(options.catch(err)))
-    }
-  })
-export {
-  /**
-   * The `Micro` equivalent of a try / catch block, which allows you to map
-   * thrown errors to a specific error type.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category constructors
-   * @example
-   * ```ts
-   * import { Micro } from "effect"
-   *
-   * Micro.try({
-   *   try: () => throw new Error("boom"),
-   *   catch: (cause) => new Error("caught", { cause })
-   * })
-   * ```
-   */
-  try_ as try
-}
+export const exitDie = (defect: unknown): MicroExit<never> => exitFailCause(causeDie(defect))
 
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
- * `CauseDie`.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Micro<A> =>
-  async<A>(function(resume, signal) {
-    evaluate(signal).then(
-      (a) => resume(succeed(a)),
-      (e) => resume(die(e))
-    )
-  })
+export const exitIsSuccess = <A, E>(
+  self: MicroExit<A, E>
+): self is MicroExit.Success<A, E> => self._tag === "Success"
 
 /**
- * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
- * converted into a specific error type.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
- * @example
- * ```ts
- * import { Micro } from "effect"
- *
- * Micro.tryPromise({
- *   try: () => Promise.resolve("success"),
- *   catch: (cause) => new Error("caught", { cause })
- * })
- * ```
+ * @category MicroExit
  */
-export const tryPromise = <A, E>(options: {
-  readonly try: (signal: AbortSignal) => PromiseLike<A>
-  readonly catch: (error: unknown) => E
-}): Micro<A, E> =>
-  async<A, E>(function(resume, signal) {
-    try {
-      options.try(signal).then(
-        (a) => resume(succeed(a)),
-        (e) => resume(fail(options.catch(e)))
-      )
-    } catch (err) {
-      resume(fail(options.catch(err)))
-    }
-  })
+export const exitIsFailure = <A, E>(
+  self: MicroExit<A, E>
+): self is MicroExit.Failure<A, E> => self._tag === "Failure"
 
 /**
- * Pause the execution of the current `Micro` effect, and resume it on the next
- * iteration of the event loop.
- *
- * You can specify a priority for the task, which will determine when it is
- * executed relative to other tasks.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const yieldWithPriority = (priority: number): Micro<void> =>
-  make(function(env, onExit) {
-    envGet(env, currentScheduler).scheduleTask(() => onExit(exitVoid), priority)
-  })
+export const exitIsInterrupt = <A, E>(
+  self: MicroExit<A, E>
+): self is MicroExit.Failure<A, E> & {
+  readonly cause: MicroCause.Interrupt
+} => exitIsFailure(self) && self.cause._tag === "Interrupt"
 
 /**
- * Pause the execution of the current `Micro` effect, and resume it on the next
- * iteration of the event loop.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const yieldNow: Micro<void> = yieldWithPriority(0)
+export const exitIsFail = <A, E>(
+  self: MicroExit<A, E>
+): self is MicroExit.Failure<A, E> & {
+  readonly cause: MicroCause.Fail<E>
+} => exitIsFailure(self) && self.cause._tag === "Fail"
 
 /**
- * Flush any yielded effects that are waiting to be executed.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const yieldFlush: Micro<void> = make(function(env, onExit) {
-  envGet(env, currentScheduler).flush()
-  onExit(exitVoid)
-})
+export const exitIsDie = <A, E>(
+  self: MicroExit<A, E>
+): self is MicroExit.Failure<A, E> & {
+  readonly cause: MicroCause.Die
+} => exitIsFailure(self) && self.cause._tag === "Die"
 
 /**
- * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
- * the Javascript runtime from exiting.
- *
- * @since 3.4.0
+ * @since 3.4.6
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const never: Micro<never> = async<never>(function() {
-  const interval = setInterval(constVoid, 2147483646)
-  return sync(() => clearInterval(interval))
-})
+export const exitVoid: MicroExit<void> = exitSucceed(void 0)
 
 /**
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category constructors
+ * @category MicroExit
  */
-export const gen = <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(
-  ...args:
-    | [self: Self, body: (this: Self) => Generator<Eff, AEff, never>]
-    | [body: () => Generator<Eff, AEff, never>]
-): Micro<
-  AEff,
-  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never,
-  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never
-> =>
-  make(function(env, onExit) {
-    const iterator: Generator<Eff, AEff, any> = args.length === 1 ? args[0]() : args[1].call(args[0])
-    let running = false
-    let value: any = undefined
-    function run() {
-      running = true
-      try {
-        let shouldContinue = true
-        while (shouldContinue) {
-          const result = iterator.next(value)
-          if (result.done) {
-            return onExit(exitSucceed(result.value))
-          }
-          shouldContinue = false
-          yieldWrapGet(result.value)[runSymbol](env, function(exit) {
-            if (exit._tag === "Left") {
-              onExit(exit)
-            } else {
-              shouldContinue = true
-              value = exit.right
-              if (!running) run()
-            }
-          })
-        }
-      } catch (err) {
-        onExit(exitDie(err))
-      }
-      running = false
+export const exitVoidAll = <I extends Iterable<MicroExit<any, any>>>(
+  exits: I
+): MicroExit<void, I extends Iterable<MicroExit<infer _A, infer _E>> ? _E : never> => {
+  for (const exit of exits) {
+    if (exit._tag === "Failure") {
+      return exit
     }
-    run()
-  })
+  }
+  return exitVoid
+}
 
 // ----------------------------------------------------------------------------
-// mapping & sequencing
+// scheduler
 // ----------------------------------------------------------------------------
 
 /**
- * Flattens any nested `Micro` effects, merging the error and requirement types.
- *
- * @since 3.4.0
+ * @since 3.5.9
  * @experimental
- * @category mapping & sequencing
+ * @category scheduler
  */
-export const flatten = <A, E, R, E2, R2>(self: Micro<Micro<A, E, R>, E2, R2>): Micro<A, E | E2, R | R2> =>
-  make(function(env, onExit) {
-    self[runSymbol](
-      env,
-      (exit) => exit._tag === "Left" ? onExit(exit as MicroExit<never, E2>) : exit.right[runSymbol](env, onExit)
-    )
-  })
+export interface MicroScheduler {
+  readonly scheduleTask: (task: () => void, priority: number) => void
+  readonly shouldYield: (fiber: Fiber<unknown, unknown>) => boolean
+  readonly flush: () => void
+}
+
+const setImmediate = "setImmediate" in globalThis
+  ? globalThis.setImmediate
+  : (f: () => void) => setTimeout(f, 0)
 
 /**
- * Transforms the success value of the `Micro` effect with the specified
- * function.
- *
- * @since 3.4.0
+ * @since 3.5.9
  * @experimental
- * @category mapping & sequencing
+ * @category scheduler
  */
-export const map: {
+export class MicroSchedulerDefault implements MicroScheduler {
+  private tasks: Array<() => void> = []
+  private running = false
+
   /**
-   * Transforms the success value of the `Micro` effect with the specified
-   * function.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
+   * @since 3.5.9
    */
-  <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
+  scheduleTask(task: () => void, _priority: number) {
+    this.tasks.push(task)
+    if (!this.running) {
+      this.running = true
+      setImmediate(this.afterScheduled)
+    }
+  }
+
   /**
-   * Transforms the success value of the `Micro` effect with the specified
-   * function.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
+   * @since 3.5.9
    */
-  <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>
-} = dual(2, <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R> =>
-  make(function(env, onExit) {
-    self[runSymbol](env, function(exit) {
-      onExit(exit._tag === "Left" ? exit as MicroExit<never, E> : exitSucceed(f(exit.right)))
-    })
-  }))
+  afterScheduled = () => {
+    this.running = false
+    this.runTasks()
+  }
 
-/**
- * Create a `Micro` effect that will replace the success value of the given
- * effect.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export const as: {
   /**
-   * Create a `Micro` effect that will replace the success value of the given
-   * effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
+   * @since 3.5.9
    */
-  <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
+  runTasks() {
+    const tasks = this.tasks
+    this.tasks = []
+    for (let i = 0, len = tasks.length; i < len; i++) {
+      tasks[i]()
+    }
+  }
+
   /**
-   * Create a `Micro` effect that will replace the success value of the given
-   * effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
+   * @since 3.5.9
    */
-  <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>
-} = dual(2, <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R> => map(self, (_) => value))
+  shouldYield(fiber: Fiber<unknown, unknown>) {
+    return fiber.currentOpCount >= fiber.getRef(MaxOpsBeforeYield)
+  }
 
-/**
- * Wrap the success value of this `Micro` effect in an `Option.Some`.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export const asSome = <A, E, R>(self: Micro<A, E, R>): Micro<Option.Option<A>, E, R> => map(self, Option.some)
+  /**
+   * @since 3.5.9
+   */
+  flush() {
+    while (this.tasks.length > 0) {
+      this.runTasks()
+    }
+  }
+}
 
 /**
- * Map the success value of this `Micro` effect to another `Micro` effect, then
- * flatten the result.
+ * Access the given `Context.Tag` from the environment.
  *
  * @since 3.4.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export const flatMap: {
+export const service: {
   /**
-   * Map the success value of this `Micro` effect to another `Micro` effect, then
-   * flatten the result.
+   * Access the given `Context.Tag` from the environment.
    *
    * @since 3.4.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>
+  <I, S>(tag: Context.Reference<I, S>): Micro<S>
   /**
-   * Map the success value of this `Micro` effect to another `Micro` effect, then
-   * flatten the result.
+   * Access the given `Context.Tag` from the environment.
    *
    * @since 3.4.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2> =>
-    make(function(env, onExit) {
-      self[runSymbol](env, function(exit) {
-        if (exit._tag === "Left") {
-          return onExit(exit as MicroExit<never, E>)
-        }
-        f(exit.right)[runSymbol](env, onExit)
-      })
-    })
-)
+  <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I>
+} =
+  (<I, S>(tag: Context.Tag<I, S>): Micro<S, never, I> =>
+    withFiber((fiber) => succeed(Context.unsafeGet(fiber.context, tag)))) as any
 
 /**
- * Swap the error and success types of the `Micro` effect.
+ * Access the given `Context.Tag` from the environment, without tracking the
+ * dependency at the type level.
+ *
+ * It will return an `Option` of the service, depending on whether it is
+ * available in the environment or not.
  *
  * @since 3.4.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export const flip = <A, E, R>(self: Micro<A, E, R>): Micro<E, A, R> =>
-  matchEffect(self, {
-    onFailure: succeed,
-    onSuccess: fail
-  })
+export const serviceOption = <I, S>(
+  tag: Context.Tag<I, S>
+): Micro<Option.Option<S>> => withFiber((fiber) => succeed(Context.getOption(fiber.context, tag)))
 
 /**
- * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
- * a single api.
- *
- * It also allows you to pass in a `Micro` effect directly, which will be
- * executed after the current effect.
+ * Update the Context with the given mapping function.
  *
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export const andThen: {
-  /**
-   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-   * a single api.
-   *
-   * It also allows you to pass in a `Micro` effect directly, which will be
-   * executed after the current effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
-   */
-  <A, X>(f: (a: A) => X): <E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
-  /**
-   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-   * a single api.
-   *
-   * It also allows you to pass in a `Micro` effect directly, which will be
-   * executed after the current effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category mapping & sequencing
-   */
-  <X>(f: NotFunction<X>): <A, E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
+export const updateContext: {
   /**
-   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-   * a single api.
+   * Update the Context with the given mapping function.
    *
-   * It also allows you to pass in a `Micro` effect directly, which will be
-   * executed after the current effect.
-   *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: A) => X
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
+  <R2, R>(
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
+  ): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
   /**
-   * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
-   * a single api.
-   *
-   * It also allows you to pass in a `Micro` effect directly, which will be
-   * executed after the current effect.
+   * Update the Context with the given mapping function.
    *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, E, R, X>(
+  <A, E, R, R2>(
     self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
+  ): Micro<A, E, R2>
 } = dual(
   2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: any): Micro<B, E | E2, R | R2> =>
-    make(function(env, onExit) {
-      self[runSymbol](env, function(exit) {
-        if (exit._tag === "Left") {
-          return onExit(exit as MicroExit<never, E>)
-        } else if (envGet(env, currentAbortSignal).aborted) {
-          return onExit(exitInterrupt)
-        }
-        const value = isMicro(f) ? f : typeof f === "function" ? f(exit.right) : f
-        if (isMicro(value)) {
-          value[runSymbol](env, onExit)
-        } else {
-          onExit(exitSucceed(value))
+  <A, E, R, R2>(
+    self: Micro<A, E, R>,
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
+  ): Micro<A, E, R2> =>
+    withFiber<
+      /**
+       * Update the Context with the given mapping function.
+       *
+       * @since 3.11.0
+       * @experimental
+       * @category environment
+       */
+      A, /**
+       * Update the Context with the given mapping function.
+       *
+       * @since 3.11.0
+       * @experimental
+       * @category environment
+       */
+      E, /**
+       * Update the Context with the given mapping function.
+       *
+       * @since 3.11.0
+       * @experimental
+       * @category environment
+       */
+      R2
+    >((fiber) => {
+      const prev = fiber.context as Context.Context<R2>
+      fiber.context = f(prev)
+      return onExit(
+        self as any,
+        () => {
+          fiber.context = prev
+          return void_
         }
-      })
+      )
     })
 )
 
 /**
- * Execute a side effect from the success value of the `Micro` effect.
- *
- * It is similar to the `andThen` api, but the success value is ignored.
+ * Update the service for the given `Context.Tag` in the environment.
  *
- * @since 3.4.0
+ * @since 3.11.0
  * @experimental
- * @category mapping & sequencing
+ * @category environment
  */
-export const tap: {
+export const updateService: {
   /**
-   * Execute a side effect from the success value of the `Micro` effect.
+   * Update the service for the given `Context.Tag` in the environment.
    *
-   * It is similar to the `andThen` api, but the success value is ignored.
-   *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, X>(f: (a: NoInfer<A>) => X): <E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
-    : Micro<A, E, R>
+  <I, A>(tag: Context.Reference<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>
   /**
-   * Execute a side effect from the success value of the `Micro` effect.
-   *
-   * It is similar to the `andThen` api, but the success value is ignored.
+   * Update the service for the given `Context.Tag` in the environment.
    *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <X>(f: NotFunction<X>): <A, E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
-    : Micro<A, E, R>
+  <I, A>(tag: Context.Tag<I, A>, f: (value: A) => A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R | I>
   /**
-   * Execute a side effect from the success value of the `Micro` effect.
+   * Update the service for the given `Context.Tag` in the environment.
    *
-   * It is similar to the `andThen` api, but the success value is ignored.
-   *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: NoInfer<A>) => X
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
-    : Micro<A, E, R>
+  <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Reference<I, A>, f: (value: A) => A): Micro<XA, E, R>
   /**
-   * Execute a side effect from the success value of the `Micro` effect.
-   *
-   * It is similar to the `andThen` api, but the success value is ignored.
+   * Update the service for the given `Context.Tag` in the environment.
    *
-   * @since 3.4.0
+   * @since 3.11.0
    * @experimental
-   * @category mapping & sequencing
+   * @category environment
    */
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1>
-    : Micro<A, E, R>
+  <XA, E, R, I, A>(self: Micro<XA, E, R>, tag: Context.Tag<I, A>, f: (value: A) => A): Micro<XA, E, R | I>
 } = dual(
-  2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2> =>
-    make(function(env, onExit) {
-      self[runSymbol](env, function(selfExit) {
-        if (selfExit._tag === "Left") {
-          return onExit(selfExit as MicroExit<never, E>)
-        } else if (envGet(env, currentAbortSignal).aborted) {
-          return onExit(exitInterrupt)
-        }
-        const value = isMicro(f) ? f : typeof f === "function" ? f(selfExit.right) : f
-        if (isMicro(value)) {
-          value[runSymbol](env, function(tapExit) {
-            if (tapExit._tag === "Left") {
-              return onExit(tapExit)
-            }
-            onExit(selfExit)
-          })
-        } else {
-          onExit(selfExit)
+  3,
+  <XA, E, R, I, A>(
+    self: Micro<XA, E, R>,
+    tag: Context.Reference<I, A>,
+    f: (value: A) => A
+  ): Micro<XA, E, R> =>
+    withFiber((fiber) => {
+      const prev = Context.unsafeGet(fiber.context, tag)
+      fiber.context = Context.add(fiber.context, tag, f(prev))
+      return onExit(
+        self,
+        () => {
+          fiber.context = Context.add(fiber.context, tag, prev)
+          return void_
         }
-      })
+      )
     })
 )
-
-/**
- * Replace the success value of the `Micro` effect with `void`.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export const asVoid = <A, E, R>(self: Micro<A, E, R>): Micro<void, E, R> => map(self, (_) => void 0)
-
-/**
- * Access the `MicroExit` of the given `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category mapping & sequencing
- */
-export const exit = <A, E, R>(self: Micro<A, E, R>): Micro<MicroExit<A, E>, never, R> =>
-  make(function(env, onExit) {
-    self[runSymbol](env, function(exit) {
-      onExit(exitSucceed(exit))
-    })
-  })
-
-/**
- * Replace the error type of the given `Micro` with the full `MicroCause` object.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export const sandbox = <A, E, R>(self: Micro<A, E, R>): Micro<A, MicroCause<E>, R> =>
-  catchAllCause(self, (cause) => fail(cause))
-
-function forkSignal(env: Env<any>) {
-  const controller = new AbortController()
-  const parentSignal = envGet(env, currentAbortSignal)
-  function onAbort() {
-    controller.abort()
-    parentSignal.removeEventListener("abort", onAbort)
-  }
-  parentSignal.addEventListener("abort", onAbort)
-  const envWithSignal = envMutate(env, function(refs) {
-    refs[currentAbortController.key] = controller
-    refs[currentAbortSignal.key] = controller.signal
-    return refs
-  })
-  return [envWithSignal, onAbort] as const
-}
-
-/**
- * Returns an effect that races all the specified effects,
- * yielding the value of the first effect to succeed with a value. Losers of
- * the race will be interrupted immediately
+
+/**
+ * Access the current `Context` from the environment.
  *
  * @since 3.4.0
  * @experimental
- * @category sequencing
+ * @category environment
  */
-export const raceAll = <Eff extends Micro<any, any, any>>(
-  all: Iterable<Eff>
-): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  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 exit: MicroExit<any, any> | undefined = undefined
-    const causes: Array<MicroCause<any>> = []
-    function onDone(exit_: MicroExit<any, any>) {
-      done++
-      if (exit_._tag === "Right" && exit === undefined) {
-        len = index
-        exit = exit_
-        onAbort()
-      } else if (exit_._tag === "Left") {
-        causes.push(exit_.left)
-      }
-      if (done >= len) {
-        onExit(exit ?? Either.left(causes[0]))
-      }
-    }
-
-    for (; index < len; index++) {
-      effects[index][runSymbol](envWithSignal, onDone)
-    }
-  })
+export const context = <R>(): Micro<Context.Context<R>> => getContext as any
+const getContext = withFiber((fiber) => succeed(fiber.context))
 
 /**
- * Returns an effect that races all the specified effects,
- * yielding the value of the first effect to succeed or fail. Losers of
- * the race will be interrupted immediately
+ * Merge the given `Context` with the current context.
  *
  * @since 3.4.0
  * @experimental
- * @category sequencing
+ * @category environment
  */
-export const raceAllFirst = <Eff extends Micro<any, any, any>>(
-  all: Iterable<Eff>
-): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  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 exit: MicroExit<any, any> | undefined = undefined
-    const causes: Array<MicroCause<any>> = []
-    function onDone(exit_: MicroExit<any, any>) {
-      done++
-      if (exit === undefined) {
-        len = index
-        exit = exit_
-        onAbort()
-      }
-      if (done >= len) {
-        onExit(exit ?? Either.left(causes[0]))
-      }
-    }
-
-    for (; index < len; index++) {
-      effects[index][runSymbol](envWithSignal, onDone)
-    }
-  })
+export const provideContext: {
+  /**
+   * Merge the given `Context` with the current context.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category environment
+   */
+  <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>
+  /**
+   * Merge the given `Context` with the current context.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category environment
+   */
+  <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>
+} = dual(
+  2,
+  <A, E, R, XR>(
+    self: Micro<A, E, R>,
+    provided: Context.Context<XR>
+  ): Micro<A, E, Exclude<R, XR>> => updateContext(self, Context.merge(provided)) as any
+)
 
 /**
- * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed. Losers of the race will be interrupted immediately
+ * Add the provided service to the current context.
  *
  * @since 3.4.0
  * @experimental
- * @category sequencing
+ * @category environment
  */
-export const race: {
+export const provideService: {
   /**
-   * Returns an effect that races two effects, yielding the value of the first
-   * effect to succeed. Losers of the race will be interrupted immediately
+   * Add the provided service to the current context.
    *
    * @since 3.4.0
    * @experimental
-   * @category sequencing
+   * @category environment
    */
-  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
+  <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>
   /**
-   * Returns an effect that races two effects, yielding the value of the first
-   * effect to succeed. Losers of the race will be interrupted immediately
+   * Add the provided service to the current context.
    *
    * @since 3.4.0
    * @experimental
-   * @category sequencing
+   * @category environment
    */
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>
+  <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>
 } = dual(
-  2,
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2> =>
-    raceAll([self, that])
+  3,
+  <A, E, R, I, S>(
+    self: Micro<A, E, R>,
+    tag: Context.Tag<I, S>,
+    service: S
+  ): Micro<A, E, Exclude<R, I>> => updateContext(self, Context.add(tag, service)) as any
 )
 
 /**
- * Returns an effect that races two effects, yielding the value of the first
- * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+ * Create a service using the provided `Micro` effect, and add it to the
+ * current context.
+ *
+ * @since 3.4.6
+ * @experimental
+ * @category environment
+ */
+export const provideServiceEffect: {
+  /**
+   * Create a service using the provided `Micro` effect, and add it to the
+   * current context.
+   *
+   * @since 3.4.6
+   * @experimental
+   * @category environment
+   */
+  <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>
+  /**
+   * Create a service using the provided `Micro` effect, and add it to the
+   * current context.
+   *
+   * @since 3.4.6
+   * @experimental
+   * @category environment
+   */
+  <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>
+} = dual(
+  3,
+  <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> => flatMap(acquire, (service) => provideService(self, tag, service))
+)
+
+// ========================================================================
+// References
+// ========================================================================
+
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category references
+ */
+export class MaxOpsBeforeYield extends Context.Reference<MaxOpsBeforeYield>()<
+  "effect/Micro/currentMaxOpsBeforeYield",
+  number
+>(
+  "effect/Micro/currentMaxOpsBeforeYield",
+  { defaultValue: () => 2048 }
+) {}
+
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category environment refs
+ */
+export class CurrentConcurrency extends Context.Reference<CurrentConcurrency>()<
+  "effect/Micro/currentConcurrency",
+  "unbounded" | number
+>(
+  "effect/Micro/currentConcurrency",
+  { defaultValue: () => "unbounded" }
+) {}
+
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category environment refs
+ */
+export class CurrentScheduler extends Context.Reference<CurrentScheduler>()<
+  "effect/Micro/currentScheduler",
+  MicroScheduler
+>(
+  "effect/Micro/currentScheduler",
+  { defaultValue: () => new MicroSchedulerDefault() }
+) {}
+
+/**
+ * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
+ * api to control the concurrency of that `Micro` when it is run.
  *
  * @since 3.4.0
  * @experimental
- * @category sequencing
+ * @category environment refs
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+ *   concurrency: "inherit"
+ * }).pipe(
+ *   Micro.withConcurrency(2) // use a concurrency of 2
+ * )
  */
-export const raceFirst: {
+export const withConcurrency: {
   /**
-   * Returns an effect that races two effects, yielding the value of the first
-   * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+   * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
+   * api to control the concurrency of that `Micro` when it is run.
    *
    * @since 3.4.0
    * @experimental
-   * @category sequencing
+   * @category environment refs
+   * @example
+   * import * as Micro from "effect/Micro"
+   *
+   * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+   *   concurrency: "inherit"
+   * }).pipe(
+   *   Micro.withConcurrency(2) // use a concurrency of 2
+   * )
    */
-  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
+  (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
   /**
-   * Returns an effect that races two effects, yielding the value of the first
-   * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+   * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
+   * api to control the concurrency of that `Micro` when it is run.
    *
    * @since 3.4.0
    * @experimental
-   * @category sequencing
+   * @category environment refs
+   * @example
+   * import * as Micro from "effect/Micro"
+   *
+   * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+   *   concurrency: "inherit"
+   * }).pipe(
+   *   Micro.withConcurrency(2) // use a concurrency of 2
+   * )
    */
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>
+  <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>
 } = dual(
   2,
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2> =>
-    raceAllFirst([self, that])
+  <A, E, R>(
+    self: Micro<A, E, R>,
+    concurrency: "unbounded" | number
+  ): Micro<A, E, R> => provideService(self, CurrentConcurrency, concurrency)
 )
 
 // ----------------------------------------------------------------------------
@@ -2212,13 +2464,11 @@ export const zipWith: {
   that: Micro<A2, E2, R2>,
   f: (a: A, b: A2) => B,
   options?: { readonly concurrent?: boolean | undefined }
-): Micro<B, E2 | E, R2 | R> => {
-  if (options?.concurrent) {
+): Micro<B, E2 | E, R2 | R> =>
+  options?.concurrent
     // Use `all` exclusively for concurrent cases, as it introduces additional overhead due to the management of concurrency
-    return map(all([self, that], { concurrency: "unbounded" }), ([a, a2]) => f(a, a2))
-  }
-  return flatMap(self, (a) => map(that, (a2) => f(a, a2)))
-})
+    ? map(all([self, that], { concurrency: 2 }), ([a, a2]) => f(a, a2))
+    : flatMap(self, (a) => map(that, (a2) => f(a, a2))))
 
 // ----------------------------------------------------------------------------
 // filtering & conditionals
@@ -2431,7 +2681,7 @@ export const when: {
     self: Micro<A, E, R>,
     condition: LazyArg<boolean> | Micro<boolean, E2, R2>
   ): Micro<Option.Option<A>, E | E2, R | R2> =>
-    flatMap(isMicro(condition) ? condition : sync(condition), (pass) => pass ? asSome(self) : succeed(Option.none()))
+    flatMap(isMicro(condition) ? condition : sync(condition), (pass) => pass ? asSome(self) : succeedNone)
 )
 
 // ----------------------------------------------------------------------------
@@ -2497,14 +2747,15 @@ export const repeatExit: {
   times?: number | undefined
   schedule?: MicroSchedule | undefined
 }): Micro<A, E, R> =>
-  make(function(env, onExit) {
+  suspend(() => {
     const startedAt = options.schedule ? Date.now() : 0
     let attempt = 0
-    self[runSymbol](env, function loop(exit) {
+
+    const loop: Micro<A, E, R> = flatMap(exit(self), (exit) => {
       if (options.while !== undefined && !options.while(exit)) {
-        return onExit(exit)
+        return exit
       } else if (options.times !== undefined && attempt >= options.times) {
-        return onExit(exit)
+        return exit
       }
       attempt++
       let delayEffect = yieldNow
@@ -2512,17 +2763,14 @@ export const repeatExit: {
         const elapsed = Date.now() - startedAt
         const duration = options.schedule(attempt, elapsed)
         if (Option.isNone(duration)) {
-          return onExit(exit)
+          return exit
         }
         delayEffect = sleep(duration.value)
       }
-      delayEffect[runSymbol](env, function(exit) {
-        if (exit._tag === "Left") {
-          return onExit(exit as MicroExit<never, never>)
-        }
-        self[runSymbol](env, loop)
-      })
+      return flatMap(delayEffect, () => loop)
     })
+
+    return loop
   }))
 
 /**
@@ -2575,9 +2823,116 @@ export const repeat: {
 ): Micro<A, E, R> =>
   repeatExit(self, {
     ...options,
-    while: (exit) => exit._tag === "Right" && (options?.while === undefined || options.while(exit.right))
+    while: (exit) => exit._tag === "Success" && (options?.while === undefined || options.while(exit.value))
   }))
 
+/**
+ * Replicates the given effect `n` times.
+ *
+ * @since 3.11.0
+ * @experimental
+ * @category repetition
+ */
+export const replicate: {
+  /**
+   * Replicates the given effect `n` times.
+   *
+   * @since 3.11.0
+   * @experimental
+   * @category repetition
+   */
+  (n: number): <A, E, R>(self: Micro<A, E, R>) => Array<Micro<A, E, R>>
+  /**
+   * Replicates the given effect `n` times.
+   *
+   * @since 3.11.0
+   * @experimental
+   * @category repetition
+   */
+  <A, E, R>(self: Micro<A, E, R>, n: number): Array<Micro<A, E, R>>
+} = dual(
+  2,
+  <A, E, R>(self: Micro<A, E, R>, n: number): Array<Micro<A, E, R>> => Array.from({ length: n }, () => self)
+)
+
+/**
+ * Performs this effect the specified number of times and collects the
+ * results.
+ *
+ * @since 3.11.0
+ * @category repetition
+ */
+export const replicateEffect: {
+  /**
+   * Performs this effect the specified number of times and collects the
+   * results.
+   *
+   * @since 3.11.0
+   * @category repetition
+   */
+  (
+    n: number,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    }
+  ): <A, E, R>(self: Micro<A, E, R>) => Micro<Array<A>, E, R>
+  /**
+   * Performs this effect the specified number of times and collects the
+   * results.
+   *
+   * @since 3.11.0
+   * @category repetition
+   */
+  (
+    n: number,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>
+  /**
+   * Performs this effect the specified number of times and collects the
+   * results.
+   *
+   * @since 3.11.0
+   * @category repetition
+   */
+  <A, E, R>(
+    self: Micro<A, E, R>,
+    n: number,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    }
+  ): Micro<Array<A>, E, R>
+  /**
+   * Performs this effect the specified number of times and collects the
+   * results.
+   *
+   * @since 3.11.0
+   * @category repetition
+   */
+  <A, E, R>(
+    self: Micro<A, E, R>,
+    n: number,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Micro<void, E, R>
+} = dual(
+  (args) => isMicro(args[0]),
+  <A, E, R>(
+    self: Micro<A, E, R>,
+    n: number,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Micro<void, E, R> => all(replicate(self, n), options)
+)
+
 /**
  * Repeat the given `Micro` effect forever, only stopping if the effect fails.
  *
@@ -2848,8 +3203,20 @@ export const catchAllCause: {
   <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> => catchCauseIf(self, constTrue, f) as Micro<A | B, E2, R | R2>
+  ): Micro<A | B, E2, R | R2> => {
+    const onFailure = Object.create(OnFailureProto)
+    onFailure[args] = self
+    onFailure[failureCont] = f
+    return onFailure
+  }
 )
+const OnFailureProto = makePrimitiveProto({
+  op: "OnFailure",
+  eval(this: any, fiber: FiberImpl): Primitive {
+    fiber._stack.push(this as any)
+    return this[args]
+  }
+})
 
 /**
  * Selectively catch a `MicroCause` object of the given `Micro` effect,
@@ -2871,7 +3238,9 @@ export 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>
+  ): <A, R>(
+    self: Micro<A, E, R>
+  ) => Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>
   /**
    * Selectively catch a `MicroCause` object of the given `Micro` effect,
    * using the provided predicate to determine if the failure should be caught.
@@ -2910,20 +3279,15 @@ export const catchCauseIf: {
     predicate: Predicate<MicroCause<NoInfer<E>>>,
     f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
   ): Micro<A | B, E | E2, R | R2>
-} = dual(3, <A, E, R, B, E2, R2>(
-  self: Micro<A, E, R>,
-  predicate: Predicate<MicroCause<E>>,
-  f: (cause: MicroCause<E>) => Micro<B, E2, R2>
-): Micro<A | B, E | E2, R | R2> =>
-  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)
-      }
-    })
-  }))
+} = dual(
+  3,
+  <A, E, R, B, E2, R2>(
+    self: Micro<A, E, R>,
+    predicate: Predicate<MicroCause<E>>,
+    f: (cause: MicroCause<E>) => Micro<B, E2, R2>
+  ): Micro<A | B, E | E2, R | R2> =>
+    catchAllCause(self, (cause) => predicate(cause) ? f(cause) : failCause(cause) as any)
+)
 
 /**
  * Catch the error of the given `Micro` effect, allowing you to recover from it.
@@ -2960,7 +3324,7 @@ export const catchAll: {
   <A, E, R, B, E2, R2>(
     self: Micro<A, E, R>,
     f: (a: NoInfer<E>) => Micro<B, E2, R2>
-  ): Micro<A | B, E2, R | R2> => catchAllCause(self, (cause) => causeIsFail(cause) ? f(cause.error) : failCause(cause))
+  ): Micro<A | B, E2, R | R2> => catchCauseIf(self, causeIsFail, (cause) => f(cause.error))
 )
 
 /**
@@ -3396,7 +3760,7 @@ export const ignoreLogged = <A, E, R>(self: Micro<A, E, R>): Micro<void, never,
  * @category error handling
  */
 export const option = <A, E, R>(self: Micro<A, E, R>): Micro<Option.Option<A>, never, R> =>
-  match(self, { onFailure: (_) => Option.none(), onSuccess: Option.some })
+  match(self, { onFailure: Option.none, onSuccess: Option.some })
 
 /**
  * Replace the success value of the given `Micro` effect with an `Either`,
@@ -3458,8 +3822,8 @@ export const retry: {
   repeatExit(self, {
     ...options,
     while: (exit) =>
-      exit._tag === "Left" && exit.left._tag === "Fail" &&
-      (options?.while === undefined || options.while(exit.left.error))
+      exit._tag === "Failure" && exit.cause._tag === "Fail" &&
+      (options?.while === undefined || options.while(exit.cause.error))
   }))
 
 /**
@@ -3506,12 +3870,7 @@ export const withTrace: {
     const lineMatch = line.match(/\((.*)\)$/)
     return causeWithTrace(cause, `at ${name} (${lineMatch ? lineMatch[1] : line})`)
   }
-  const f = (name: string) => (self: Micro<any, any, any>) =>
-    unsafeMakeOptions(function(env, onExit) {
-      self[runSymbol](env, function(exit) {
-        onExit(exit._tag === "Left" ? Either.left(generate(name, exit.left)) : exit)
-      })
-    }, false)
+  const f = (name: string) => (self: Micro<any, any, any>) => onError(self, (cause) => failCause(generate(name, cause)))
   if (arguments.length === 2) {
     return f(arguments[1])(arguments[0])
   }
@@ -3567,18 +3926,21 @@ export const matchCauseEffect: {
       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> =>
-    make(function(env, onExit) {
-      self[runSymbol](env, function(exit) {
-        try {
-          const next = exit._tag === "Left" ? options.onFailure(exit.left) : options.onSuccess(exit.right)
-          next[runSymbol](env, onExit)
-        } catch (err) {
-          onExit(exitDie(err))
-        }
-      })
-    })
+  ): Micro<A2 | A3, E2 | E3, R2 | R3 | R> => {
+    const primitive = Object.create(OnSuccessAndFailureProto)
+    primitive[args] = self
+    primitive[successCont] = options.onSuccess
+    primitive[failureCont] = options.onFailure
+    return primitive
+  }
 )
+const OnSuccessAndFailureProto = makePrimitiveProto({
+  op: "OnSuccessAndFailure",
+  eval(this: any, fiber: FiberImpl): Primitive {
+    fiber._stack.push(this)
+    return this[args]
+  }
+})
 
 /**
  * @since 3.4.6
@@ -3724,12 +4086,12 @@ export const match: {
  * @category delays & timeouts
  */
 export const sleep = (millis: number): Micro<void> =>
-  async(function(resume) {
-    const timeout = setTimeout(function() {
+  async((resume) => {
+    const timeout = setTimeout(() => {
       resume(void_)
     }, millis)
     return sync(() => {
-      return clearTimeout(timeout)
+      clearTimeout(timeout)
     })
   })
 
@@ -3997,7 +4359,7 @@ class MicroScopeImpl implements MicroScope.Closeable {
         this.state = { _tag: "Closed", exit: microExit }
         return flatMap(
           forEach(finalizers, (finalizer) => exit(finalizer(microExit))),
-          (exits) => asVoid(fromExit(Either.all(exits)))
+          exitVoidAll
         )
       }
       return void_
@@ -4082,7 +4444,7 @@ export const provideScope: {
  * @category resources & finalization
  */
 export const scoped = <A, E, R>(self: Micro<A, E, R>): Micro<A, E, Exclude<R, MicroScope>> =>
-  suspend(function() {
+  suspend(() => {
     const scope = new MicroScopeImpl()
     return onExit(provideService(self, MicroScope, scope), (exit) => scope.close(exit))
   })
@@ -4149,7 +4511,45 @@ export const onExit: {
   <A, E, R, XE, XR>(
     self: Micro<A, E, R>,
     f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR> => onExitIf(self, constTrue, f)
+  ): Micro<A, E | XE, R | XR> =>
+    uninterruptibleMask((restore) =>
+      matchCauseEffect(restore(self), {
+        onFailure: (cause) => flatMap(f(exitFailCause(cause)), () => failCause(cause)),
+        onSuccess: (a) => flatMap(f(exitSucceed(a)), () => succeed(a))
+      })
+    )
+)
+
+/**
+ * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export const ensuring: {
+  /**
+   * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category resources & finalization
+   */
+  <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
+  /**
+   * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+   *
+   * @since 3.4.0
+   * @experimental
+   * @category resources & finalization
+   */
+  <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>
+} = dual(
+  2,
+  <A, E, R, XE, XR>(
+    self: Micro<A, E, R>,
+    finalizer: Micro<void, XE, XR>
+  ): Micro<A, E | XE, R | XR> => onExit(self, (_) => finalizer)
 )
 
 /**
@@ -4217,52 +4617,7 @@ export const onExitIf: {
     self: Micro<A, E, R>,
     refinement: Refinement<MicroExit<A, E>, B>,
     f: (exit: B) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR> =>
-    uninterruptibleMask((restore) =>
-      make(function(env, onExit) {
-        restore(self)[runSymbol](env, function(exit) {
-          if (!refinement(exit)) {
-            return onExit(exit)
-          }
-          f(exit)[runSymbol](env, function(finalizerExit) {
-            if (finalizerExit._tag === "Left") {
-              return onExit(finalizerExit as MicroExit<never, XE>)
-            }
-            onExit(exit)
-          })
-        })
-      })
-    )
-)
-
-/**
- * Regardless of the result of the this `Micro` effect, run the finalizer effect.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const ensuring: {
-  /**
-   * Regardless of the result of the this `Micro` effect, run the finalizer effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category resources & finalization
-   */
-  <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  /**
-   * Regardless of the result of the this `Micro` effect, run the finalizer effect.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category resources & finalization
-   */
-  <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>
-} = dual(
-  2,
-  <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR> =>
-    onExit(self, (_) => finalizer)
+  ): Micro<A, E | XE, R | XR> => onExit(self, (exit) => (refinement(exit) ? f(exit) : exitVoid))
 )
 
 /**
@@ -4302,7 +4657,7 @@ export const onError: {
   <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> => onExitIf(self, exitIsFailure, (exit) => f(exit.left))
+  ): Micro<A, E | XE, R | XR> => onExitIf(self, exitIsFailure, (exit) => f(exit.cause))
 )
 
 /**
@@ -4354,7 +4709,7 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
       (a) =>
         flatMap(
           exit(restore(use(a))),
-          (exit) => andThen(release(a, exit), fromExit(exit))
+          (exit) => andThen(release(a, exit), exit)
         )
     )
   )
@@ -4370,29 +4725,54 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
  * @experimental
  * @category interruption
  */
-export const interrupt: Micro<never> = make(function(env, onExit) {
-  const controller = envGet(env, currentAbortController)
-  controller.abort()
-  onExit(exitInterrupt)
+export const interrupt: Micro<never> = failCause(causeInterrupt())
+
+/**
+ * Flag the effect as uninterruptible, which means that when the effect is
+ * interrupted, it will be allowed to continue running until completion.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category flags
+ */
+export const uninterruptible = <A, E, R>(
+  self: Micro<A, E, R>
+): Micro<A, E, R> =>
+  withFiber((fiber) => {
+    if (!fiber.interruptible) return self
+    fiber.interruptible = false
+    fiber._stack.push(setInterruptible(true))
+    return self
+  })
+
+const setInterruptible: (interruptible: boolean) => Primitive = makePrimitive({
+  op: "SetInterruptible",
+  ensure(fiber) {
+    fiber.interruptible = this[args]
+    if (fiber._interrupted && fiber.interruptible) {
+      return () => exitInterrupt
+    }
+  }
 })
 
 /**
- * Wrap the given `Micro` effect in an uninterruptible region, preventing the
- * effect from being aborted.
+ * Flag the effect as interruptible, which means that when the effect is
+ * interrupted, it will be interrupted immediately.
  *
  * @since 3.4.0
  * @experimental
- * @category interruption
+ * @category flags
  */
-export const uninterruptible = <A, E, R>(self: Micro<A, E, R>): Micro<A, E, R> =>
-  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, onExit)
-  }, false)
+export const interruptible = <A, E, R>(
+  self: Micro<A, E, R>
+): Micro<A, E, R> =>
+  withFiber((fiber) => {
+    if (fiber.interruptible) return self
+    fiber.interruptible = true
+    fiber._stack.push(setInterruptible(false))
+    if (fiber._interrupted) return exitInterrupt
+    return self
+  })
 
 /**
  * Wrap the given `Micro` effect in an uninterruptible region, preventing the
@@ -4416,42 +4796,15 @@ export const uninterruptible = <A, E, R>(self: Micro<A, E, R>): Micro<A, E, R> =
  * ```
  */
 export const uninterruptibleMask = <A, E, R>(
-  f: (restore: <A, E, R>(effect: Micro<A, E, R>) => Micro<A, E, R>) => Micro<A, E, R>
+  f: (
+    restore: <A, E, R>(effect: Micro<A, E, R>) => Micro<A, E, R>
+  ) => Micro<A, E, R>
 ): Micro<A, E, R> =>
-  unsafeMakeOptions((env, onExit) => {
-    const isInterruptible = envGet(env, currentInterruptible)
-    const effect = isInterruptible ? f(interruptible) : f(identity)
-    const nextEnv = isInterruptible ?
-      envMutate(env, function(env) {
-        env[currentInterruptible.key] = false
-        env[currentAbortSignal.key] = new AbortController().signal
-        return env
-      }) :
-      env
-    effect[runSymbol](nextEnv, onExit)
-  }, false)
-
-/**
- * Wrap the given `Micro` effect in an interruptible region, allowing the effect
- * to be aborted.
- *
- * @since 3.4.0
- * @experimental
- * @category interruption
- */
-export const interruptible = <A, E, R>(self: Micro<A, E, R>): Micro<A, E, R> =>
-  make((env, onExit) => {
-    const isInterruptible = envGet(env, currentInterruptible)
-    let newEnv = env
-    if (!isInterruptible) {
-      const controller = envGet(env, currentAbortController)
-      newEnv = envMutate(env, function(env) {
-        env[currentInterruptible.key] = true
-        env[currentAbortSignal.key] = controller.signal
-        return env
-      })
-    }
-    self[runSymbol](newEnv, onExit)
+  withFiber((fiber) => {
+    if (!fiber.interruptible) return f(identity)
+    fiber.interruptible = false
+    fiber._stack.push(setInterruptible(true))
+    return f(interruptible)
   })
 
 // ========================================================================
@@ -4571,6 +4924,34 @@ export const all = <
   }) as any
 }
 
+/**
+ * @since 3.11.0
+ * @experimental
+ * @category collecting & elements
+ */
+export const whileLoop: <A, E, R>(options: {
+  readonly while: LazyArg<boolean>
+  readonly body: LazyArg<Micro<A, E, R>>
+  readonly step: (a: A) => void
+}) => Micro<void, E, R> = makePrimitive({
+  op: "While",
+  contA(value, fiber) {
+    this[args].step(value)
+    if (this[args].while()) {
+      fiber._stack.push(this)
+      return this[args].body()
+    }
+    return exitVoid
+  },
+  eval(fiber) {
+    if (this[args].while()) {
+      fiber._stack.push(this)
+      return this[args].body()
+    }
+    return exitVoid
+  }
+})
+
 /**
  * For each element of the provided iterable, run the effect and collect the results.
  *
@@ -4636,64 +5017,89 @@ export const forEach: {
   readonly concurrency?: Concurrency | undefined
   readonly discard?: boolean | undefined
 }): Micro<any, E, R> =>
-  make(function(env, onExit) {
+  withFiber((parent) => {
     const concurrencyOption = options?.concurrency === "inherit"
-      ? envGet(env, currentConcurrency)
+      ? parent.getRef(CurrentConcurrency)
       : options?.concurrency ?? 1
     const concurrency = concurrencyOption === "unbounded"
       ? Number.POSITIVE_INFINITY
       : Math.max(1, concurrencyOption)
 
-    // abort
-    const [envWithSignal, onAbort] = forkSignal(env)
-
-    // iterate
-    let result: MicroExit<any, any> | undefined = undefined
-    const items = Array.from(iterable)
+    const items = Arr.fromIterable(iterable)
     let length = items.length
     if (length === 0) {
-      return onExit(Either.right(options?.discard ? undefined : []))
+      return options?.discard ? void_ : succeed([])
     }
+
     const out: Array<B> | undefined = options?.discard ? undefined : new Array(length)
     let index = 0
-    let inProgress = 0
-    let doneCount = 0
-    let pumping = false
-    function pump() {
-      pumping = true
-      while (inProgress < concurrency && index < length) {
-        const currentIndex = index
-        const item = items[currentIndex]
-        index++
-        inProgress++
-        try {
-          f(item, currentIndex)[runSymbol](envWithSignal, function(exit) {
-            if (exit._tag === "Left") {
-              if (result === undefined) {
-                result = exit
-                length = index
-                onAbort()
+
+    if (concurrency === 1) {
+      return as(
+        whileLoop({
+          while: () => index < items.length,
+          body: () => f(items[index], index),
+          step: out ?
+            (b) => out[index++] = b :
+            (_) => index++
+        }),
+        out as any
+      )
+    }
+    return async((resume) => {
+      const fibers = new Set<Fiber<unknown, unknown>>()
+      let result: MicroExit<any, any> | undefined = undefined
+      let inProgress = 0
+      let doneCount = 0
+      let pumping = false
+      let interrupted = false
+      function pump() {
+        pumping = true
+        while (inProgress < concurrency && index < length) {
+          const currentIndex = index
+          const item = items[currentIndex]
+          index++
+          inProgress++
+          try {
+            const child = unsafeFork(parent, f(item, currentIndex), true, true)
+            fibers.add(child)
+            child.addObserver((exit) => {
+              fibers.delete(child)
+              if (interrupted) {
+                return
+              } else if (exit._tag === "Failure") {
+                if (result === undefined) {
+                  result = exit
+                  length = index
+                  fibers.forEach((fiber) => fiber.unsafeInterrupt())
+                }
+              } else if (out !== undefined) {
+                out[currentIndex] = exit.value
               }
-            } else if (out !== undefined) {
-              out[currentIndex] = exit.right
-            }
-            doneCount++
-            inProgress--
-            if (doneCount === length) {
-              onExit(result ?? Either.right(out))
-            } else if (!pumping && inProgress < concurrency) {
-              pump()
-            }
-          })
-        } catch (err) {
-          result = exitDie(err)
-          length = index
-          onAbort()
+              doneCount++
+              inProgress--
+              if (doneCount === length) {
+                resume(result ?? succeed(out))
+              } else if (!pumping && inProgress < concurrency) {
+                pump()
+              }
+            })
+          } catch (err) {
+            result = exitDie(err)
+            length = index
+            fibers.forEach((fiber) => fiber.unsafeInterrupt())
+          }
         }
+        pumping = false
       }
-      pumping = false
-    }
-    pump()
+      pump()
+
+      return suspend(() => {
+        interrupted = true
+        index = length
+        return fiberInterruptAll(fibers)
+      })
+    })
   })
 
 /**
@@ -4843,151 +5249,9 @@ export {
 }
 
 // ----------------------------------------------------------------------------
-// handle & forking
+// fibers & forking
 // ----------------------------------------------------------------------------
 
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export const HandleTypeId: unique symbol = Symbol.for("effect/Micro/Handle")
-
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export type HandleTypeId = typeof HandleTypeId
-
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export interface Handle<A, E = never> extends Micro<A, E> {
-  readonly [HandleTypeId]: HandleTypeId
-  readonly await: Micro<MicroExit<A, E>>
-  readonly join: Micro<A, E>
-  readonly interrupt: Micro<MicroExit<A, E>>
-  readonly unsafeInterrupt: () => void
-  readonly addObserver: (observer: (exit: MicroExit<A, E>) => void) => void
-  readonly removeObserver: (observer: (exit: MicroExit<A, E>) => void) => void
-  readonly unsafePoll: () => MicroExit<A, E> | null
-
-  [Unify.typeSymbol]?: unknown
-  [Unify.unifySymbol]?: HandleUnify<this>
-  [Unify.ignoreSymbol]?: HandleUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface HandleUnify<A extends { [Unify.typeSymbol]?: any }> extends MicroUnify<A> {
-  Handle?: () => A[Unify.typeSymbol] extends Handle<infer A0, infer E0> | infer _ ? Handle<A0, E0> : never
-}
-
-/**
- * @category models
- * @since 3.8.4
- * @experimental
- */
-export interface HandleUnifyIgnore extends MicroUnifyIgnore {
-  Micro?: true
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category handle & forking
- */
-export const isHandle = (u: unknown): u is Handle<unknown, unknown> =>
-  typeof u === "object" && u !== null && HandleTypeId in u
-
-class HandleImpl<A, E> extends Class<A, E> implements Handle<A, E> {
-  readonly [HandleTypeId]: HandleTypeId
-
-  readonly observers: Set<(exit: MicroExit<A, E>) => void> = new Set()
-  private _exit: MicroExit<A, E> | undefined = undefined
-  _controller: AbortController
-  readonly isRoot: boolean
-
-  constructor(readonly parentSignal: AbortSignal, controller?: AbortController) {
-    super()
-    this[HandleTypeId] = HandleTypeId
-    this.isRoot = controller !== undefined
-    this._controller = controller ?? new AbortController()
-    if (!this.isRoot) {
-      parentSignal.addEventListener("abort", this.unsafeInterrupt)
-    }
-  }
-
-  unsafePoll(): MicroExit<A, E> | null {
-    return this._exit ?? null
-  }
-
-  unsafeInterrupt = () => {
-    this._controller.abort()
-  }
-
-  emit(exit: MicroExit<A, E>): void {
-    if (this._exit) {
-      return
-    }
-    this._exit = exit
-    if (!this.isRoot) {
-      this.parentSignal.removeEventListener("abort", this.unsafeInterrupt)
-    }
-    this.observers.forEach((observer) => observer(exit))
-    this.observers.clear()
-  }
-
-  addObserver(observer: (exit: MicroExit<A, E>) => void): void {
-    if (this._exit) {
-      return observer(this._exit)
-    }
-    this.observers.add(observer)
-  }
-
-  removeObserver(observer: (exit: MicroExit<A, E>) => void): void {
-    this.observers.delete(observer)
-  }
-
-  get await(): Micro<MicroExit<A, E>> {
-    return suspend(() => {
-      if (this._exit) {
-        return succeed(this._exit)
-      }
-      return async((resume) => {
-        function observer(exit: MicroExit<A, E>) {
-          resume(succeed(exit))
-        }
-        this.addObserver(observer)
-        return sync(() => {
-          this.removeObserver(observer)
-        })
-      })
-    })
-  }
-
-  get join(): Micro<A, E> {
-    return flatMap(this.await, fromExit)
-  }
-
-  get interrupt(): Micro<MicroExit<A, E>> {
-    return suspend(() => {
-      this.unsafeInterrupt()
-      return this.await
-    })
-  }
-
-  asMicro(): Micro<A, E> {
-    return this.join
-  }
-}
-
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -4998,23 +5262,33 @@ class HandleImpl<A, E> extends Class<A, E> implements Handle<A, E> {
  * @experimental
  * @category handle & forking
  */
-export const fork = <A, E, R>(self: Micro<A, E, R>): Micro<Handle<A, E>, never, R> =>
-  make(function(env, onExit) {
-    const signal = envGet(env, currentAbortSignal)
-    const handle = new HandleImpl<A, E>(signal)
-    const nextEnv = envMutate(env, (map) => {
-      map[currentAbortController.key] = handle._controller
-      map[currentAbortSignal.key] = handle._controller.signal
-      return map
-    })
-    envGet(env, currentScheduler).scheduleTask(() => {
-      self[runSymbol](nextEnv, (exit) => {
-        handle.emit(exit)
-      })
-    }, 0)
-    onExit(Either.right(handle))
+export const fork = <A, E, R>(
+  self: Micro<A, E, R>
+): Micro<Fiber<A, E>, never, R> =>
+  withFiber((fiber) => {
+    fiberMiddleware.interruptChildren ??= fiberInterruptChildren
+    return succeed(unsafeFork(fiber, self))
   })
 
+const unsafeFork = <FA, FE, A, E, R>(
+  parent: FiberImpl<FA, FE>,
+  effect: Micro<A, E, R>,
+  immediate = false,
+  daemon = false
+): Fiber<A, E> => {
+  const child = new FiberImpl<A, E>(parent.context, parent.interruptible)
+  if (!daemon) {
+    parent.children().add(child)
+    child.addObserver(() => parent.children().delete(child))
+  }
+  if (immediate) {
+    child.evaluate(effect as any)
+  } else {
+    parent.getRef(CurrentScheduler).scheduleTask(() => child.evaluate(effect as any), 0)
+  }
+  return child
+}
+
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
  * aborted.
@@ -5025,22 +5299,9 @@ export const fork = <A, E, R>(self: Micro<A, E, R>): Micro<Handle<A, E>, never,
  * @experimental
  * @category handle & forking
  */
-export const forkDaemon = <A, E, R>(self: Micro<A, E, R>): Micro<Handle<A, E>, never, R> =>
-  make(function(env, onExit) {
-    const controller = new AbortController()
-    const handle = new HandleImpl<A, E>(controller.signal, controller)
-    const nextEnv = envMutate(env, (map) => {
-      map[currentAbortController.key] = controller
-      map[currentAbortSignal.key] = controller.signal
-      return map
-    })
-    envGet(env, currentScheduler).scheduleTask(() => {
-      self[runSymbol](nextEnv, (exit) => {
-        handle.emit(exit)
-      })
-    }, 0)
-    onExit(Either.right(handle))
-  })
+export const forkDaemon = <A, E, R>(
+  self: Micro<A, E, R>
+): Micro<Fiber<A, E>, never, R> => withFiber((fiber) => succeed(unsafeFork(fiber, self, false, true)))
 
 /**
  * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
@@ -5063,7 +5324,7 @@ export const forkIn: {
    * @experimental
    * @category handle & forking
    */
-  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>
+  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Fiber<A, E>, never, R>
   /**
    * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
    * aborted.
@@ -5074,15 +5335,15 @@ export const forkIn: {
    * @experimental
    * @category handle & forking
    */
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Handle<A, E>, never, R>
+  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R>
 } = dual(
   2,
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Handle<A, E>, never, R> =>
+  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Fiber<A, E>, never, R> =>
     uninterruptibleMask((restore) =>
       flatMap(scope.fork, (scope) =>
         tap(
           restore(forkDaemon(onExit(self, (exit) => scope.close(exit)))),
-          (fiber) => scope.addFinalizer((_) => asVoid(fiber.interrupt))
+          (fiber) => scope.addFinalizer((_) => fiberInterrupt(fiber))
         ))
     )
 )
@@ -5097,7 +5358,7 @@ export const forkIn: {
  * @experimental
  * @category handle & forking
  */
-export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<Handle<A, E>, never, R | MicroScope> =>
+export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<Fiber<A, E>, never, R | MicroScope> =>
   flatMap(scope, (scope) => forkIn(self, scope))
 
 // ----------------------------------------------------------------------------
@@ -5134,28 +5395,21 @@ export const runFork = <A, E>(
     readonly signal?: AbortSignal | undefined
     readonly scheduler?: MicroScheduler | undefined
   } | undefined
-): Handle<A, E> => {
-  const controller = new AbortController()
-  const refs = Object.create(null)
-  refs[currentAbortController.key] = controller
-  refs[currentAbortSignal.key] = controller.signal
-  refs[currentScheduler.key] = options?.scheduler ?? new MicroSchedulerDefault()
-  const env = envMake(refs)
-  const handle = new HandleImpl<A, E>(controller.signal, controller)
-  effect[runSymbol](envSet(env, currentAbortSignal, handle._controller.signal), (exit) => {
-    handle.emit(exit)
-    if (options?.signal) {
-      options.signal.removeEventListener("abort", handle.unsafeInterrupt)
-    }
-  })
+): FiberImpl<A, E> => {
+  const fiber = new FiberImpl<A, E>(CurrentScheduler.context(
+    options?.scheduler ?? new MicroSchedulerDefault()
+  ))
+  fiber.evaluate(effect as any)
   if (options?.signal) {
     if (options.signal.aborted) {
-      handle.unsafeInterrupt()
+      fiber.unsafeInterrupt()
     } else {
-      options.signal.addEventListener("abort", handle.unsafeInterrupt, { once: true })
+      const abort = () => fiber.unsafeInterrupt()
+      options.signal.addEventListener("abort", abort, { once: true })
+      fiber.addObserver(() => options.signal!.removeEventListener("abort", abort))
     }
   }
-  return handle
+  return fiber
 }
 
 /**
@@ -5194,10 +5448,10 @@ export const runPromise = <A, E>(
   } | undefined
 ): Promise<A> =>
   runPromiseExit(effect, options).then((exit) => {
-    if (exit._tag === "Left") {
-      throw exit.left
+    if (exit._tag === "Failure") {
+      throw exit.cause
     }
-    return exit.right
+    return exit.value
   })
 
 /**
@@ -5212,13 +5466,9 @@ export const runPromise = <A, E>(
  */
 export const runSyncExit = <A, E>(effect: Micro<A, E>): MicroExit<A, E> => {
   const scheduler = new MicroSchedulerDefault()
-  const handle = runFork(effect, { scheduler })
+  const fiber = runFork(effect, { scheduler })
   scheduler.flush()
-  const exit = handle.unsafePoll()
-  if (exit === null) {
-    return exitDie(handle)
-  }
-  return exit
+  return fiber._exit ?? exitDie(fiber)
 }
 
 /**
@@ -5231,10 +5481,8 @@ export const runSyncExit = <A, E>(effect: Micro<A, E>): MicroExit<A, E> => {
  */
 export const runSync = <A, E>(effect: Micro<A, E>): A => {
   const exit = runSyncExit(effect)
-  if (exit._tag === "Left") {
-    throw exit.left
-  }
-  return exit.right
+  if (exit._tag === "Failure") throw exit.cause
+  return exit.value
 }
 
 // ----------------------------------------------------------------------------
@@ -5247,35 +5495,35 @@ export const runSync = <A, E>(effect: Micro<A, E>): A => {
  * @category errors
  */
 export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
-  readonly [EffectTypeId]: Effect.VarianceStruct<never, this, never>
-  readonly [StreamTypeId]: Stream.VarianceStruct<never, this, never>
-  readonly [SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>
-  readonly [ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>
+  readonly [Effectable.EffectTypeId]: Effect.VarianceStruct<never, this, never>
+  readonly [Effectable.StreamTypeId]: Stream.VarianceStruct<never, this, never>
+  readonly [Effectable.SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>
+  readonly [Effectable.ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>
   readonly [TypeId]: Micro.Variance<never, this, never>
-  readonly [runSymbol]: (env: Env<any>, onExit: (exit: MicroExit<never, this>) => void) => void
   [Symbol.iterator](): MicroIterator<Micro<never, this, never>>
 }
 
 const YieldableError: new(message?: string) => YieldableError = (function() {
-  class YieldableError extends globalThis.Error {
-    [runSymbol](_env: any, onExit: any) {
-      onExit(exitFail(this))
-    }
-    toString() {
+  class YieldableError extends globalThis.Error {}
+  Object.assign(YieldableError.prototype, MicroProto, StructuralPrototype, {
+    [identifier]: "Failure",
+    [evaluate]() {
+      return fail(this)
+    },
+    toString(this: Error) {
       return this.message ? `${this.name}: ${this.message}` : this.name
-    }
+    },
     toJSON() {
       return { ...this }
-    }
-    [NodeInspectSymbol](): string {
+    },
+    [NodeInspectSymbol](this: Error): string {
       const stack = this.stack
       if (stack) {
         return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
       }
       return this.toString()
     }
-  }
-  Object.assign(YieldableError.prototype, MicroProto, StructuralPrototype)
+  })
   return YieldableError as any
 })()