@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/Micro.ts

@@ -1,4405 +0,0 @@
-/**
- * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
- *
- * @since 3.4.0
- * @experimental
- */
-import * as Arr from "./Array.js"
-import type { Channel } from "./Channel.js"
-import * as Context from "./Context.js"
-import type { Effect, EffectUnify, EffectUnifyIgnore } from "./Effect.js"
-import * as Effectable from "./Effectable.js"
-import * as Either from "./Either.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 { 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 * as Option from "./Option.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, NoExcessProperties, NotFunction, Simplify } from "./Types.js"
-import type * as Unify from "./Unify.js"
-import { SingleShotGen, YieldWrap, yieldWrapGet } from "./Utils.js"
-
-/**
- * @since 3.4.0
- * @experimental
- * @category type ids
- */
-export const TypeId: unique symbol = Symbol.for("effect/Micro")
-
-/**
- * @since 3.4.0
- * @experimental
- * @category type ids
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 3.4.0
- * @experimental
- * @category MicroExit
- */
-export const MicroExitTypeId: unique symbol = Symbol.for(
-  "effect/Micro/MicroExit"
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category MicroExit
- */
-export type MicroExitTypeId = typeof TypeId
-
-/**
- * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
- *
- * @since 3.4.0
- * @experimental
- * @category models
- */
-export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
-  readonly [TypeId]: Micro.Variance<A, E, R>
-  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>
-  [Unify.typeSymbol]?: unknown
-  [Unify.unifySymbol]?: MicroUnify<this>
-  [Unify.ignoreSymbol]?: MicroUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.4.3
- */
-export interface MicroUnify<A extends { [Unify.typeSymbol]?: any }> extends EffectUnify<A> {
-  Micro?: () => A[Unify.typeSymbol] extends Micro<infer A0, infer E0, infer R0> | infer _ ? Micro<A0, E0, R0> : never
-}
-
-/**
- * @category models
- * @since 3.4.3
- */
-export interface MicroUnifyIgnore extends EffectUnifyIgnore {
-  Effect?: true
-}
-/**
- * @category type lambdas
- * @since 3.4.1
- */
-export interface MicroTypeLambda extends TypeLambda {
-  readonly type: Micro<this["Target"], this["Out1"], this["Out2"]>
-}
-
-/**
- * @since 3.4.0
- * @experimental
- */
-export declare namespace Micro {
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export interface Variance<A, E, R> {
-    _A: Covariant<A>
-    _E: Covariant<E>
-    _R: Covariant<R>
-  }
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type Success<T> = T extends Micro<infer _A, infer _E, infer _R> ? _A : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type Error<T> = T extends Micro<infer _A, infer _E, infer _R> ? _E : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type Context<T> = T extends Micro<infer _A, infer _E, infer _R> ? _R : never
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category guards
- */
-export const isMicro = (u: unknown): u is Micro<any, any, any> => typeof u === "object" && u !== null && TypeId in u
-
-/**
- * @since 3.4.0
- * @experimental
- * @category models
- */
-export interface MicroIterator<T extends Micro<any, any, any>> {
-  next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>
-}
-
-// ----------------------------------------------------------------------------
-// MicroCause
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const MicroCauseTypeId = Symbol.for("effect/Micro/MicroCause")
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export type MicroCauseTypeId = typeof MicroCauseTypeId
-
-/**
- * A `MicroCause` is a data type that represents the different ways a `Micro` can fail.
- *
- * **Details**
- *
- * `MicroCause` comes in three forms:
- *
- * - `Die`: Indicates an unforeseen defect that wasn't planned for in the system's logic.
- * - `Fail`: Covers anticipated errors that are recognized and typically handled within the application.
- * - `Interrupt`: Signifies an operation that has been purposefully stopped.
- *
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export type MicroCause<E> =
-  | MicroCause.Die
-  | MicroCause.Fail<E>
-  | MicroCause.Interrupt
-
-/**
- * @since 3.6.6
- * @experimental
- * @category guards
- */
-export const isMicroCause = (self: unknown): self is MicroCause<unknown> => hasProperty(self, MicroCauseTypeId)
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export declare namespace MicroCause {
-  /**
-   * @since 3.4.6
-   * @experimental
-   */
-  export type Error<T> = T extends MicroCause.Fail<infer E> ? E : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export interface Proto<Tag extends string, E> extends Pipeable, globalThis.Error {
-    readonly [MicroCauseTypeId]: {
-      _E: Covariant<E>
-    }
-    readonly _tag: Tag
-    readonly traces: ReadonlyArray<string>
-  }
-
-  /**
-   * @since 3.4.6
-   * @experimental
-   * @category MicroCause
-   */
-  export interface Die extends Proto<"Die", never> {
-    readonly defect: unknown
-  }
-
-  /**
-   * @since 3.4.6
-   * @experimental
-   * @category MicroCause
-   */
-  export interface Fail<E> extends Proto<"Fail", E> {
-    readonly error: E
-  }
-
-  /**
-   * @since 3.4.6
-   * @experimental
-   * @category MicroCause
-   */
-  export interface Interrupt extends Proto<"Interrupt", never> {}
-}
-
-const microCauseVariance = {
-  _E: identity
-}
-
-abstract class MicroCauseImpl<Tag extends string, E> extends globalThis.Error implements MicroCause.Proto<Tag, E> {
-  readonly [MicroCauseTypeId]: {
-    _E: Covariant<E>
-  }
-  constructor(
-    readonly _tag: Tag,
-    originalError: unknown,
-    readonly traces: ReadonlyArray<string>
-  ) {
-    const causeName = `MicroCause.${_tag}`
-    let name: string
-    let message: string
-    let stack: string
-    if (originalError instanceof globalThis.Error) {
-      name = `(${causeName}) ${originalError.name}`
-      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")
-        }`
-        : `${name}: ${message}`
-    } else {
-      name = causeName
-      message = toStringUnknown(originalError, 0)
-      stack = `${name}: ${message}`
-    }
-    if (traces.length > 0) {
-      stack += `\n    ${traces.join("\n    ")}`
-    }
-    super(message)
-    this[MicroCauseTypeId] = microCauseVariance
-    this.name = name
-    this.stack = stack
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-  toString() {
-    return this.stack
-  }
-  [NodeInspectSymbol]() {
-    return this.stack
-  }
-}
-
-class Fail<E> extends MicroCauseImpl<"Fail", E> implements MicroCause.Fail<E> {
-  constructor(
-    readonly error: E,
-    traces: ReadonlyArray<string> = []
-  ) {
-    super("Fail", error, traces)
-  }
-}
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeFail = <E>(
-  error: E,
-  traces: ReadonlyArray<string> = []
-): MicroCause<E> => new Fail(error, traces)
-
-class Die extends MicroCauseImpl<"Die", never> implements MicroCause.Die {
-  constructor(
-    readonly defect: unknown,
-    traces: ReadonlyArray<string> = []
-  ) {
-    super("Die", defect, traces)
-  }
-}
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeDie = (
-  defect: unknown,
-  traces: ReadonlyArray<string> = []
-): MicroCause<never> => new Die(defect, traces)
-
-class Interrupt extends MicroCauseImpl<"Interrupt", never> implements MicroCause.Interrupt {
-  constructor(traces: ReadonlyArray<string> = []) {
-    super("Interrupt", "interrupted", traces)
-  }
-}
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeInterrupt = (
-  traces: ReadonlyArray<string> = []
-): MicroCause<never> => new Interrupt(traces)
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeIsFail = <E>(
-  self: MicroCause<E>
-): self is MicroCause.Fail<E> => self._tag === "Fail"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeIsDie = <E>(self: MicroCause<E>): self is MicroCause.Die => self._tag === "Die"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeIsInterrupt = <E>(
-  self: MicroCause<E>
-): self is MicroCause.Interrupt => self._tag === "Interrupt"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeSquash = <E>(self: MicroCause<E>): unknown =>
-  self._tag === "Fail" ? self.error : self._tag === "Die" ? self.defect : self
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroCause
- */
-export const causeWithTrace: {
-  (trace: string): <E>(self: MicroCause<E>) => MicroCause<E>
-  <E>(self: MicroCause<E>, trace: string): MicroCause<E>
-} = dual(2, <E>(self: MicroCause<E>, trace: string): MicroCause<E> => {
-  const traces = [...self.traces, trace]
-  switch (self._tag) {
-    case "Die":
-      return causeDie(self.defect, traces)
-    case "Interrupt":
-      return causeInterrupt(traces)
-    case "Fail":
-      return causeFail(self.error, traces)
-  }
-})
-
-// ----------------------------------------------------------------------------
-// MicroFiber
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export const MicroFiberTypeId = Symbol.for("effect/Micro/MicroFiber")
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export type MicroFiberTypeId = typeof MicroFiberTypeId
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export interface MicroFiber<out A, out E = never> {
-  readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>
-
-  readonly currentOpCount: number
-  readonly getRef: <I, A>(ref: Context.Reference<I, A>) => A
-  readonly context: Context.Context<never>
-  readonly addObserver: (cb: (exit: MicroExit<A, E>) => void) => () => void
-  readonly unsafeInterrupt: () => void
-  readonly unsafePoll: () => MicroExit<A, E> | undefined
-}
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export declare namespace MicroFiber {
-  /**
-   * @since 3.11.0
-   * @experimental
-   * @category MicroFiber
-   */
-  export interface Variance<out A, out E = never> {
-    readonly _A: Covariant<A>
-    readonly _E: Covariant<E>
-  }
-}
-
-const fiberVariance = {
-  _A: identity,
-  _E: identity
-}
-
-class MicroFiberImpl<in out A = any, in out E = any> implements MicroFiber<A, E> {
-  readonly [MicroFiberTypeId]: MicroFiber.Variance<A, E>
-
-  readonly _stack: Array<Primitive> = []
-  readonly _observers: Array<(exit: MicroExit<A, E>) => void> = []
-  _exit: MicroExit<A, E> | undefined
-  public _children: Set<MicroFiberImpl<any, any>> | undefined
-
-  public currentOpCount = 0
-
-  constructor(
-    public context: Context.Context<never>,
-    public interruptible = true
-  ) {
-    this[MicroFiberTypeId] = 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(`MicroFiber.runLoop: Not a valid effect: ${String(current)}`)
-      }
-      return exitDie(error)
-    }
-  }
-
-  getCont<S extends successCont | failureCont>(
-    symbol: S
-  ): Primitive & Record<S, (value: any, fiber: MicroFiberImpl) => 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<MicroFiber<any, any>> {
-    return this._children ??= new Set()
-  }
-}
-
-const fiberMiddleware = globalValue("effect/Micro/fiberMiddleware", () => ({
-  interruptChildren: undefined as ((fiber: MicroFiberImpl) => Micro<void> | undefined) | undefined
-}))
-
-const fiberInterruptChildren = (fiber: MicroFiberImpl) => {
-  if (fiber._children === undefined || fiber._children.size === 0) {
-    return undefined
-  }
-  return fiberInterruptAll(fiber._children)
-}
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export const fiberAwait = <A, E>(self: MicroFiber<A, E>): Micro<MicroExit<A, E>> =>
-  async((resume) => sync(self.addObserver((exit) => resume(succeed(exit)))))
-
-/**
- * @since 3.11.2
- * @experimental
- * @category MicroFiber
- */
-export const fiberJoin = <A, E>(self: MicroFiber<A, E>): Micro<A, E> => flatten(fiberAwait(self))
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export const fiberInterrupt = <A, E>(self: MicroFiber<A, E>): Micro<void> =>
-  suspend(() => {
-    self.unsafeInterrupt()
-    return asVoid(fiberAwait(self))
-  })
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroFiber
- */
-export const fiberInterruptAll = <A extends Iterable<MicroFiber<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: MicroFiberImpl) => Primitive | Yield) | undefined
-  readonly [failureCont]:
-    | ((cause: MicroCause<unknown>, fiber: MicroFiberImpl) => Primitive | Yield)
-    | undefined
-  readonly [ensureCont]:
-    | ((fiber: MicroFiberImpl) =>
-      | ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield)
-      | undefined)
-    | undefined
-  [evaluate](fiber: MicroFiberImpl): Primitive | Yield
-}
-
-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: "Micro",
-      op: this[identifier],
-      ...(args in this ? { args: this[args] } : undefined)
-    }
-  },
-  toString() {
-    return format(this)
-  },
-  [NodeInspectSymbol]() {
-    return format(this)
-  }
-}
-
-function defaultEvaluate(_fiber: MicroFiberImpl): Primitive | Yield {
-  return exitDie(`Micro.evaluate: Not implemented`) as any
-}
-
-const makePrimitiveProto = <Op extends string>(options: {
-  readonly op: Op
-  readonly eval?: (fiber: MicroFiberImpl) => Primitive | Micro<any, any, any> | Yield
-  readonly contA?: (this: Primitive, value: any, fiber: MicroFiberImpl) => Primitive | Micro<any, any, any> | Yield
-  readonly contE?: (
-    this: Primitive,
-    cause: MicroCause<any>,
-    fiber: MicroFiberImpl
-  ) => Primitive | Micro<any, any, any> | Yield
-  readonly ensure?: (this: Primitive, fiber: MicroFiberImpl) => void | ((value: any, fiber: MicroFiberImpl) => 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: MicroFiberImpl
-  ) => Primitive | Micro<any, any, any> | Yield
-  readonly contA?: (
-    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
-    value: any,
-    fiber: MicroFiberImpl
-  ) => Primitive | Micro<any, any, any> | Yield
-  readonly contE?: (
-    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
-    cause: MicroCause<any>,
-    fiber: MicroFiberImpl
-  ) => Primitive | Micro<any, any, any> | Yield
-  readonly ensure?: (
-    this: Primitive & { readonly [args]: Single extends true ? Parameters<Fn>[0] : Parameters<Fn> },
-    fiber: MicroFiberImpl
-  ) => void | ((value: any, fiber: MicroFiberImpl) => 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: MicroFiberImpl<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: "MicroExit",
-        _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
-}
-
-/**
- * Creates a `Micro` effect that will succeed with the specified constant value.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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 constructors
- */
-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)
-  }
-})
-
-/**
- * Creates a `Micro` effect that fails with the given error.
- *
- * This results in a `Fail` variant of the `MicroCause` type, where the error is
- * tracked at the type level.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const fail = <E>(error: E): Micro<never, E> => failCause(causeFail(error))
-
-/**
- * Creates a `Micro` effect that succeeds with a lazily evaluated value.
- *
- * If the evaluation of the value throws an error, the effect will fail with a
- * `Die` variant of the `MicroCause` type.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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))
-  }
-})
-
-/**
- * Lazily creates a `Micro` effect from the given side-effect.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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 constructors
- */
-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 constructors
- */
-export const yieldNow: Micro<void> = yieldNowWith(0)
-
-/**
- * Creates a `Micro` effect that will succeed with the value wrapped in `Some`.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const succeedSome = <A>(a: A): Micro<Option.Option<A>> => succeed(Option.some(a))
-
-/**
- * Creates a `Micro` effect that succeeds with `None`.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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 constructors
- */
-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 results in a `Die` variant of the `MicroCause` type, where the error is
- * not tracked at the type level.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const die = (defect: unknown): Micro<never> => exitDie(defect)
-
-/**
- * Creates a `Micro` effect that will fail with the lazily evaluated error.
- *
- * This results in a `Fail` variant of the `MicroCause` type, 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 constructors
- */
-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 constructors
- */
-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 constructors
-   */
-  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.
-   *
-   * @example
-   * ```ts
-   * import { Micro } from "effect"
-   *
-   * Micro.try({
-   *   try: () => { throw new Error("boom") },
-   *   catch: (cause) => new Error("caught", { cause })
-   * })
-   * ```
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category constructors
-   */
-  try_ as try
-}
-
-/**
- * Wrap a `Promise` into a `Micro` effect.
- *
- * Any errors will result in a `Die` variant of the `MicroCause` type, where the
- * error is not tracked at the type level.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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)
-
-/**
- * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
- * converted into a specific error type.
- *
- * @example
- * ```ts
- * import { Micro } from "effect"
- *
- * Micro.tryPromise({
- *   try: () => Promise.resolve("success"),
- *   catch: (cause) => new Error("caught", { cause })
- * })
- * ```
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-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 `MicroFiber`.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const withMicroFiber: <A, E = never, R = never>(
-  evaluate: (fiber: MicroFiberImpl<A, E>) => Micro<A, E, R>
-) => Micro<A, E, R> = makePrimitive({
-  op: "WithMicroFiber",
-  eval(fiber) {
-    return this[args](fiber)
-  }
-})
-
-/**
- * Flush any yielded effects that are waiting to be executed.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const yieldFlush: Micro<void> = withMicroFiber((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)
-  }
-})
-
-/**
- * Create a `Micro` effect from an asynchronous computation.
- *
- * You can return a cleanup effect that will be run when the effect is aborted.
- * It is also passed an `AbortSignal` that is triggered when the effect is
- * aborted.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export 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)
-
-/**
- * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
- * the Javascript runtime from exiting.
- *
- * @since 3.4.0
- * @experimental
- * @category constructors
- */
-export const never: Micro<never> = async<never>(function() {
-  const interval = setInterval(constVoid, 2147483646)
-  return sync(() => clearInterval(interval))
-})
-
-/**
- * @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: MicroFiberImpl) {
-    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 mapping & sequencing
- */
-export const as: {
-  <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
-  <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))
-
-/**
- * Wrap the success value of this `Micro` effect in a `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)
-
-/**
- * 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 lets you directly pass a `Micro` effect, which will be executed after
- * the current effect.
- *
- * @since 3.4.0
- * @experimental
- * @category mapping & sequencing
- */
-export const andThen: {
-  <A, X>(
-    f: (a: A) => X
-  ): <E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
-  <X>(
-    f: NotFunction<X>
-  ): <A, E, R>(
-    self: Micro<A, E, R>
-  ) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: (a: A) => X
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
-  <A, E, R, X>(
-    self: Micro<A, E, R>,
-    f: NotFunction<X>
-  ): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1>
-    : Micro<X, E, R>
-} = dual(
-  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)
-    })
-)
-
-/**
- * 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
- */
-export const tap: {
-  <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>
-  <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>
-  <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>
-  <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, 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)
-    })
-)
-
-/**
- * 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> => flatMap(self, (_) => exitVoid)
-
-/**
- * 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> =>
-  matchCause(self, {
-    onFailure: exitFailCause,
-    onSuccess: exitSucceed
-  })
-
-/**
- * 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, fail)
-
-/**
- * Returns an effect that races all the specified effects,
- * yielding the value of the first effect to succeed with a value. Losers of
- * the race will be interrupted immediately
- *
- * @since 3.4.0
- * @experimental
- * @category sequencing
- */
-export const raceAll = <Eff extends Micro<any, any, any>>(
-  all: Iterable<Eff>
-): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  withMicroFiber((parent) =>
-    async((resume) => {
-      const effects = Arr.fromIterable(all)
-      const len = effects.length
-      let doneCount = 0
-      let done = false
-      const fibers = new Set<MicroFiber<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)
-    })
-  )
-
-/**
- * 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 sequencing
- */
-export const raceAllFirst = <Eff extends Micro<any, any, any>>(
-  all: Iterable<Eff>
-): Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>> =>
-  withMicroFiber((parent) =>
-    async((resume) => {
-      let done = false
-      const fibers = new Set<MicroFiber<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)
-    })
-  )
-
-/**
- * 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
- */
-export const race: {
-  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
-  <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])
-)
-
-/**
- * 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
- */
-export const raceFirst: {
-  <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
-  <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 mapping & sequencing
- */
-export const flatMap: {
-  <A, B, E2, R2>(
-    f: (a: A) => Micro<B, E2, R2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>
-  <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: MicroFiberImpl): Primitive {
-    fiber._stack.push(this)
-    return this[args]
-  }
-})
-
-// ----------------------------------------------------------------------------
-// mapping & sequencing
-// ----------------------------------------------------------------------------
-
-/**
- * Flattens any nested `Micro` effects, merging the error and requirement types.
- *
- * @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 mapping & sequencing
- */
-export const map: {
-  <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>
-  <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
-// ----------------------------------------------------------------------------
-
-/**
- * The `MicroExit` type is used to represent the result of a `Micro` computation. It
- * can either be successful, containing a value of type `A`, or it can fail,
- * containing an error of type `E` wrapped in a `MicroCause`.
- *
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export type MicroExit<A, E = never> =
-  | MicroExit.Success<A, E>
-  | MicroExit.Failure<A, E>
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-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>
-  }
-}
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const isMicroExit = (u: unknown): u is MicroExit<unknown, unknown> => hasProperty(u, MicroExitTypeId)
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitSucceed: <A>(a: A) => MicroExit<A, never> = succeed as any
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitFailCause: <E>(cause: MicroCause<E>) => MicroExit<never, E> = failCause as any
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitInterrupt: MicroExit<never> = exitFailCause(causeInterrupt())
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitFail = <E>(e: E): MicroExit<never, E> => exitFailCause(causeFail(e))
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitDie = (defect: unknown): MicroExit<never> => exitFailCause(causeDie(defect))
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitIsSuccess = <A, E>(
-  self: MicroExit<A, E>
-): self is MicroExit.Success<A, E> => self._tag === "Success"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitIsFailure = <A, E>(
-  self: MicroExit<A, E>
-): self is MicroExit.Failure<A, E> => self._tag === "Failure"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-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"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-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"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-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"
-
-/**
- * @since 3.4.6
- * @experimental
- * @category MicroExit
- */
-export const exitVoid: MicroExit<void> = exitSucceed(void 0)
-
-/**
- * @since 3.11.0
- * @experimental
- * @category MicroExit
- */
-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
-    }
-  }
-  return exitVoid
-}
-
-// ----------------------------------------------------------------------------
-// scheduler
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.5.9
- * @experimental
- * @category scheduler
- */
-export interface MicroScheduler {
-  readonly scheduleTask: (task: () => void, priority: number) => void
-  readonly shouldYield: (fiber: MicroFiber<unknown, unknown>) => boolean
-  readonly flush: () => void
-}
-
-const setImmediate = "setImmediate" in globalThis
-  ? globalThis.setImmediate
-  : (f: () => void) => setTimeout(f, 0)
-
-/**
- * @since 3.5.9
- * @experimental
- * @category scheduler
- */
-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]()
-    }
-  }
-
-  /**
-   * @since 3.5.9
-   */
-  shouldYield(fiber: MicroFiber<unknown, unknown>) {
-    return fiber.currentOpCount >= fiber.getRef(MaxOpsBeforeYield)
-  }
-
-  /**
-   * @since 3.5.9
-   */
-  flush() {
-    while (this.tasks.length > 0) {
-      this.runTasks()
-    }
-  }
-}
-
-/**
- * Access the given `Context.Tag` from the environment.
- *
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const service: {
-  <I, S>(tag: Context.Reference<I, S>): Micro<S>
-  <I, S>(tag: Context.Tag<I, S>): Micro<S, never, I>
-} =
-  (<I, S>(tag: Context.Tag<I, S>): Micro<S, never, I> =>
-    withMicroFiber((fiber) => succeed(Context.unsafeGet(fiber.context, tag)))) as any
-
-/**
- * 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 environment
- */
-export const serviceOption = <I, S>(
-  tag: Context.Tag<I, S>
-): Micro<Option.Option<S>> => withMicroFiber((fiber) => succeed(Context.getOption(fiber.context, tag)))
-
-/**
- * Update the Context with the given mapping function.
- *
- * @since 3.11.0
- * @experimental
- * @category environment
- */
-export const updateContext: {
-  <R2, R>(
-    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
-  ): <A, E>(self: Micro<A, E, R>) => Micro<A, E, R2>
-  <A, E, R, R2>(self: Micro<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): Micro<A, E, R2>
-} = dual(
-  2,
-  <A, E, R, R2>(
-    self: Micro<A, E, R>,
-    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
-  ): Micro<A, E, R2> =>
-    withMicroFiber<A, E, R2>((fiber) => {
-      const prev = fiber.context as Context.Context<R2>
-      fiber.context = f(prev)
-      return onExit(
-        self as any,
-        () => {
-          fiber.context = prev
-          return void_
-        }
-      )
-    })
-)
-
-/**
- * Update the service for the given `Context.Tag` in the environment.
- *
- * @since 3.11.0
- * @experimental
- * @category environment
- */
-export const updateService: {
-  <I, A>(
-    tag: Context.Reference<I, A>,
-    f: (value: A) => A
-  ): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, 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>
-  <XA, E, R, I, A>(
-    self: Micro<XA, E, R>,
-    tag: Context.Reference<I, A>,
-    f: (value: A) => A
-  ): Micro<XA, 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(
-  3,
-  <XA, E, R, I, A>(
-    self: Micro<XA, E, R>,
-    tag: Context.Reference<I, A>,
-    f: (value: A) => A
-  ): Micro<XA, E, R> =>
-    withMicroFiber((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_
-        }
-      )
-    })
-)
-
-/**
- * Access the current `Context` from the environment.
- *
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const context = <R>(): Micro<Context.Context<R>> => getContext as any
-const getContext = withMicroFiber((fiber) => succeed(fiber.context))
-
-/**
- * Merge the given `Context` with the current context.
- *
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const provideContext: {
-  <XR>(
-    context: Context.Context<XR>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>
-  <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
-)
-
-/**
- * Add the provided service to the current context.
- *
- * @since 3.4.0
- * @experimental
- * @category environment
- */
-export const provideService: {
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    service: S
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>
-  <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>> => updateContext(self, Context.add(tag, service)) as any
-)
-
-/**
- * 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: {
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>
-  <A, E, R, I, S, E2, R2>(
-    self: Micro<A, E, R>,
-    tag: Context.Tag<I, S>,
-    acquire: Micro<S, E2, R2>
-  ): Micro<A, E | E2, Exclude<R, I> | R2>
-} = 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.
- *
- * @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
- * )
- * ```
- *
- * @since 3.4.0
- * @experimental
- * @category environment refs
- */
-export const withConcurrency: {
-  (
-    concurrency: "unbounded" | number
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(
-    self: Micro<A, E, R>,
-    concurrency: "unbounded" | number
-  ): Micro<A, E, R>
-} = dual(
-  2,
-  <A, E, R>(
-    self: Micro<A, E, R>,
-    concurrency: "unbounded" | number
-  ): Micro<A, E, R> => provideService(self, CurrentConcurrency, concurrency)
-)
-
-// ----------------------------------------------------------------------------
-// zipping
-// ----------------------------------------------------------------------------
-
-/**
- * Combine two `Micro` effects into a single effect that produces a tuple of
- * their results.
- *
- * @since 3.4.0
- * @experimental
- * @category zipping
- */
-export const zip: {
-  <A2, E2, R2>(
-    that: Micro<A2, E2, R2>,
-    options?:
-      | { readonly concurrent?: boolean | undefined }
-      | undefined
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<[A, A2], E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2>(
-    self: Micro<A, E, R>,
-    that: Micro<A2, E2, R2>,
-    options?: { readonly concurrent?: boolean | undefined }
-  ): Micro<[A, A2], E | E2, R | R2>
-} = dual((args) => isMicro(args[1]), <A, E, R, A2, E2, R2>(
-  self: Micro<A, E, R>,
-  that: Micro<A2, E2, R2>,
-  options?: { readonly concurrent?: boolean | undefined }
-): Micro<[A, A2], E | E2, R | R2> => zipWith(self, that, (a, a2) => [a, a2], options))
-
-/**
- * The `Micro.zipWith` function combines two `Micro` effects and allows you to
- * apply a function to the results of the combined effects, transforming them
- * into a single value.
- *
- * @since 3.4.3
- * @experimental
- * @category zipping
- */
-export const zipWith: {
-  <A2, E2, R2, A, B>(
-    that: Micro<A2, E2, R2>,
-    f: (a: A, b: A2) => B,
-    options?: { readonly concurrent?: boolean | undefined }
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R2 | R>
-  <A, E, R, A2, E2, R2, B>(
-    self: Micro<A, E, R>,
-    that: Micro<A2, E2, R2>,
-    f: (a: A, b: A2) => B,
-    options?: { readonly concurrent?: boolean | undefined }
-  ): Micro<B, E2 | E, R2 | R>
-} = dual((args) => isMicro(args[1]), <A, E, R, A2, E2, R2, B>(
-  self: Micro<A, E, R>,
-  that: Micro<A2, E2, R2>,
-  f: (a: A, b: A2) => B,
-  options?: { readonly concurrent?: boolean | undefined }
-): 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
-    ? map(all([self, that], { concurrency: 2 }), ([a, a2]) => f(a, a2))
-    : flatMap(self, (a) => map(that, (a2) => f(a, a2))))
-
-// ----------------------------------------------------------------------------
-// filtering & conditionals
-// ----------------------------------------------------------------------------
-
-/**
- * Filter the specified effect with the provided function, failing with specified
- * `MicroCause` if the predicate fails.
- *
- * In addition to the filtering capabilities discussed earlier, you have the option to further
- * refine and narrow down the type of the success channel by providing a
- *
- * @since 3.4.0
- * @experimental
- * @category filtering & conditionals
- */
-export const filterOrFailCause: {
-  <A, B extends A, E2>(
-    refinement: Refinement<A, B>,
-    orFailWith: (a: NoInfer<A>) => MicroCause<E2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
-  <A, E2>(
-    predicate: Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => MicroCause<E2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
-  <A, E, R, B extends A, E2>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<A, B>,
-    orFailWith: (a: A) => MicroCause<E2>
-  ): Micro<B, E | E2, R>
-  <A, E, R, E2>(
-    self: Micro<A, E, R>,
-    predicate: Predicate<A>,
-    orFailWith: (a: A) => MicroCause<E2>
-  ): Micro<A, E | E2, R>
-} = dual((args) => isMicro(args[0]), <A, E, R, B extends A, E2>(
-  self: Micro<A, E, R>,
-  refinement: Refinement<A, B>,
-  orFailWith: (a: A) => MicroCause<E2>
-): Micro<B, E | E2, R> => flatMap(self, (a) => refinement(a) ? succeed(a) : failCause(orFailWith(a))))
-
-/**
- * Filter the specified effect with the provided function, failing with specified
- * error if the predicate fails.
- *
- * In addition to the filtering capabilities discussed earlier, you have the option to further
- * refine and narrow down the type of the success channel by providing a
- *
- * @since 3.4.0
- * @experimental
- * @category filtering & conditionals
- */
-export const filterOrFail: {
-  <A, B extends A, E2>(
-    refinement: Refinement<A, B>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>
-  <A, E2>(
-    predicate: Predicate<NoInfer<A>>,
-    orFailWith: (a: NoInfer<A>) => E2
-  ): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>
-  <A, E, R, B extends A, E2>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): Micro<B, E | E2, R>
-  <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Micro<A, E | E2, R>
-} = dual((args) => isMicro(args[0]), <A, E, R, B extends A, E2>(
-  self: Micro<A, E, R>,
-  refinement: Refinement<A, B>,
-  orFailWith: (a: A) => E2
-): Micro<B, E | E2, R> => flatMap(self, (a) => refinement(a) ? succeed(a) : fail(orFailWith(a))))
-
-/**
- * The moral equivalent of `if (p) exp`.
- *
- * @since 3.4.0
- * @experimental
- * @category filtering & conditionals
- */
-export const when: {
-  <E2 = never, R2 = never>(
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>
-  <A, E, R, E2 = never, R2 = never>(
-    self: Micro<A, E, R>,
-    condition: LazyArg<boolean> | Micro<boolean, E2, R2>
-  ): Micro<Option.Option<A>, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, E2 = never, R2 = never>(
-    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) : succeedNone)
-)
-
-// ----------------------------------------------------------------------------
-// repetition
-// ----------------------------------------------------------------------------
-
-/**
- * Repeat the given `Micro` using the provided options.
- *
- * The `while` predicate will be checked after each iteration, and can use the
- * fall `MicroExit` of the effect to determine if the repetition should continue.
- *
- * @since 3.4.6
- * @experimental
- * @category repetition
- */
-export const repeatExit: {
-  <A, E>(options: {
-    while: Predicate<MicroExit<A, E>>
-    times?: number | undefined
-    schedule?: MicroSchedule | undefined
-  }): <R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(self: Micro<A, E, R>, options: {
-    while: Predicate<MicroExit<A, E>>
-    times?: number | undefined
-    schedule?: MicroSchedule | undefined
-  }): Micro<A, E, R>
-} = dual(2, <A, E, R>(self: Micro<A, E, R>, options: {
-  while: Predicate<MicroExit<A, E>>
-  times?: number | undefined
-  schedule?: MicroSchedule | undefined
-}): Micro<A, E, R> =>
-  suspend(() => {
-    const startedAt = options.schedule ? Date.now() : 0
-    let attempt = 0
-
-    const loop: Micro<A, E, R> = flatMap(exit(self), (exit) => {
-      if (options.while !== undefined && !options.while(exit)) {
-        return exit
-      } else if (options.times !== undefined && attempt >= options.times) {
-        return exit
-      }
-      attempt++
-      let delayEffect = yieldNow
-      if (options.schedule !== undefined) {
-        const elapsed = Date.now() - startedAt
-        const duration = options.schedule(attempt, elapsed)
-        if (Option.isNone(duration)) {
-          return exit
-        }
-        delayEffect = sleep(duration.value)
-      }
-      return flatMap(delayEffect, () => loop)
-    })
-
-    return loop
-  }))
-
-/**
- * Repeat the given `Micro` effect using the provided options. Only successful
- * results will be repeated.
- *
- * @since 3.4.0
- * @experimental
- * @category repetition
- */
-export const repeat: {
-  <A, E>(
-    options?: {
-      while?: Predicate<A> | undefined
-      times?: number | undefined
-      schedule?: MicroSchedule | undefined
-    } | undefined
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(
-    self: Micro<A, E, R>,
-    options?: {
-      while?: Predicate<A> | undefined
-      times?: number | undefined
-      schedule?: MicroSchedule | undefined
-    } | undefined
-  ): Micro<A, E, R>
-} = dual((args) => isMicro(args[0]), <A, E, R>(
-  self: Micro<A, E, R>,
-  options?: {
-    while?: Predicate<A> | undefined
-    times?: number | undefined
-    schedule?: MicroSchedule | undefined
-  } | undefined
-): Micro<A, E, R> =>
-  repeatExit(self, {
-    ...options,
-    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: {
-  (n: number): <A, E, R>(self: Micro<A, E, R>) => Array<Micro<A, E, R>>
-  <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: {
-  (
-    n: number,
-    options?: {
-      readonly concurrency?: Concurrency | undefined
-      readonly discard?: false | undefined
-    }
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<Array<A>, E, R>
-  (
-    n: number,
-    options: {
-      readonly concurrency?: Concurrency | undefined
-      readonly discard: true
-    }
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>
-  <A, E, R>(
-    self: Micro<A, E, R>,
-    n: number,
-    options?: {
-      readonly concurrency?: Concurrency | undefined
-      readonly discard?: false | undefined
-    }
-  ): Micro<Array<A>, E, R>
-  <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.
- *
- * @since 3.4.0
- * @experimental
- * @category repetition
- */
-export const forever = <A, E, R>(self: Micro<A, E, R>): Micro<never, E, R> => repeat(self) as any
-
-// ----------------------------------------------------------------------------
-// scheduling
-// ----------------------------------------------------------------------------
-
-/**
- * The `MicroSchedule` type represents a function that can be used to calculate
- * the delay between repeats.
- *
- * The function takes the current attempt number and the elapsed time since the
- * first attempt, and returns the delay for the next attempt. If the function
- * returns `None`, the repetition will stop.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export type MicroSchedule = (attempt: number, elapsed: number) => Option.Option<number>
-
-/**
- * Create a `MicroSchedule` that will stop repeating after the specified number
- * of attempts.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleRecurs = (n: number): MicroSchedule => (attempt) => attempt <= n ? Option.some(0) : Option.none()
-
-/**
- * Create a `MicroSchedule` that will generate a constant delay.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleSpaced = (millis: number): MicroSchedule => () => Option.some(millis)
-
-/**
- * Create a `MicroSchedule` that will generate a delay with an exponential backoff.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleExponential = (baseMillis: number, factor = 2): MicroSchedule => (attempt) =>
-  Option.some(Math.pow(factor, attempt) * baseMillis)
-
-/**
- * Returns a new `MicroSchedule` with an added calculated delay to each delay
- * returned by this schedule.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleAddDelay: {
-  (f: () => number): (self: MicroSchedule) => MicroSchedule
-  (self: MicroSchedule, f: () => number): MicroSchedule
-} = dual(
-  2,
-  (self: MicroSchedule, f: () => number): MicroSchedule => (attempt, elapsed) =>
-    Option.map(self(attempt, elapsed), (duration) => duration + f())
-)
-
-/**
- * Transform a `MicroSchedule` to one that will have a delay that will never exceed
- * the specified maximum.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleWithMaxDelay: {
-  (max: number): (self: MicroSchedule) => MicroSchedule
-  (self: MicroSchedule, max: number): MicroSchedule
-} = dual(
-  2,
-  (self: MicroSchedule, max: number): MicroSchedule => (attempt, elapsed) =>
-    Option.map(self(attempt, elapsed), (duration) => Math.min(duration, max))
-)
-
-/**
- * Transform a `MicroSchedule` to one that will stop repeating after the specified
- * amount of time.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleWithMaxElapsed: {
-  (max: number): (self: MicroSchedule) => MicroSchedule
-  (self: MicroSchedule, max: number): MicroSchedule
-} = dual(
-  2,
-  (self: MicroSchedule, max: number): MicroSchedule => (attempt, elapsed) =>
-    elapsed < max ? self(attempt, elapsed) : Option.none()
-)
-
-/**
- * Combines two `MicroSchedule`s, by recurring if either schedule wants to
- * recur, using the minimum of the two durations between recurrences.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleUnion: {
-  (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule
-  (self: MicroSchedule, that: MicroSchedule): MicroSchedule
-} = dual(
-  2,
-  (self: MicroSchedule, that: MicroSchedule): MicroSchedule => (attempt, elapsed) =>
-    Option.zipWith(self(attempt, elapsed), that(attempt, elapsed), (d1, d2) => Math.min(d1, d2))
-)
-
-/**
- * Combines two `MicroSchedule`s, by recurring only if both schedules want to
- * recur, using the maximum of the two durations between recurrences.
- *
- * @since 3.4.6
- * @experimental
- * @category scheduling
- */
-export const scheduleIntersect: {
-  (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule
-  (self: MicroSchedule, that: MicroSchedule): MicroSchedule
-} = dual(
-  2,
-  (self: MicroSchedule, that: MicroSchedule): MicroSchedule => (attempt, elapsed) =>
-    Option.zipWith(self(attempt, elapsed), that(attempt, elapsed), (d1, d2) => Math.max(d1, d2))
-)
-
-// ----------------------------------------------------------------------------
-// error handling
-// ----------------------------------------------------------------------------
-
-/**
- * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to
- * recover from any kind of cause.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const catchAllCause: {
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Micro<A, E, R>,
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): Micro<A | B, E2, R | R2>
-} = dual(
-  2,
-  <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> => {
-    const onFailure = Object.create(OnFailureProto)
-    onFailure[args] = self
-    onFailure[failureCont] = f
-    return onFailure
-  }
-)
-const OnFailureProto = makePrimitiveProto({
-  op: "OnFailure",
-  eval(this: any, fiber: MicroFiberImpl): Primitive {
-    fiber._stack.push(this as any)
-    return this[args]
-  }
-})
-
-/**
- * Selectively catch a `MicroCause` object of the given `Micro` effect,
- * using the provided predicate to determine if the failure should be caught.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-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>
-  <E, B, E2, R2>(
-    predicate: Predicate<MicroCause<NoInfer<E>>>,
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>
-  <A, E, R, B, E2, R2, EB extends MicroCause<E>>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (cause: EB) => Micro<B, E2, R2>
-  ): Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Micro<A, E, R>,
-    predicate: Predicate<MicroCause<NoInfer<E>>>,
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): Micro<A | B, E | E2, R | R2>
-} = 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.
- *
- * It only catches expected errors.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const catchAll: {
-  <E, B, E2, R2>(
-    f: (e: NoInfer<E>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>
-} = dual(
-  2,
-  <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> => catchCauseIf(self, causeIsFail, (cause) => f(cause.error))
-)
-
-/**
- * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const catchAllDefect: {
-  <E, B, E2, R2>(
-    f: (defect: unknown) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2> =>
-    catchCauseIf(self, causeIsDie, (die) => f(die.defect))
-)
-
-/**
- * Perform a side effect using the full `MicroCause` object of the given `Micro`.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const tapErrorCause: {
-  <E, B, E2, R2>(
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Micro<A, E, R>,
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): Micro<A, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(
-    self: Micro<A, E, R>,
-    f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): Micro<A, E | E2, R | R2> => tapErrorCauseIf(self, constTrue, f)
-)
-
-/**
- * Perform a side effect using if a `MicroCause` object matches the specified
- * predicate.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const tapErrorCauseIf: {
-  <E, B, E2, R2, EB extends MicroCause<E>>(
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (a: EB) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
-  <E, B, E2, R2>(
-    predicate: (cause: NoInfer<MicroCause<E>>) => boolean,
-    f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
-  <A, E, R, B, E2, R2, EB extends MicroCause<E>>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (a: EB) => Micro<B, E2, R2>
-  ): Micro<A, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Micro<A, E, R>,
-    predicate: (cause: NoInfer<MicroCause<E>>) => boolean,
-    f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>
-  ): Micro<A, E | E2, R | R2>
-} = dual(
-  3,
-  <A, E, R, B, E2, R2, EB extends MicroCause<E>>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<MicroCause<E>, EB>,
-    f: (a: EB) => Micro<B, E2, R2>
-  ): Micro<A, E | E2, R | R2> => catchCauseIf(self, refinement, (cause) => andThen(f(cause), failCause(cause)))
-)
-
-/**
- * Perform a side effect from expected errors of the given `Micro`.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const tapError: {
-  <E, B, E2, R2>(
-    f: (e: NoInfer<E>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2> =>
-    tapErrorCauseIf(self, causeIsFail, (fail) => f(fail.error))
-)
-
-/**
- * Perform a side effect from unexpected errors of the given `Micro`.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const tapDefect: {
-  <E, B, E2, R2>(
-    f: (defect: unknown) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2> =>
-    tapErrorCauseIf(self, causeIsDie, (die) => f(die.defect))
-)
-
-/**
- * Catch any expected errors that match the specified predicate.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const catchIf: {
-  <E, EB extends E, A2, E2, R2>(
-    refinement: Refinement<NoInfer<E>, EB>,
-    f: (e: EB) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
-  <E, A2, E2, R2>(
-    predicate: Predicate<NoInfer<E>>,
-    f: (e: NoInfer<E>) => Micro<A2, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
-  <A, E, R, EB extends E, A2, E2, R2>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<E, EB>,
-    f: (e: EB) => Micro<A2, E2, R2>
-  ): Micro<A | A2, E2 | Exclude<E, EB>, R | R2>
-  <A, E, R, A2, E2, R2>(
-    self: Micro<A, E, R>,
-    predicate: Predicate<E>,
-    f: (e: E) => Micro<A2, E2, R2>
-  ): Micro<A | A2, E | E2, R | R2>
-} = dual(
-  3,
-  <A, E, R, A2, E2, R2>(
-    self: Micro<A, E, R>,
-    predicate: Predicate<E>,
-    f: (e: E) => Micro<A2, E2, R2>
-  ): Micro<A | A2, E | E2, R | R2> =>
-    catchCauseIf(
-      self,
-      (f): f is MicroCause.Fail<E> => causeIsFail(f) && predicate(f.error),
-      (fail) => f(fail.error)
-    )
-)
-
-/**
- * Recovers from the specified tagged error.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const catchTag: {
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
-  <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1, A1>(
-    self: Micro<A, E, R>,
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-  ): Micro<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
-} = dual(3, <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1, A1>(
-  self: Micro<A, E, R>,
-  k: K,
-  f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-): Micro<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1> =>
-  catchIf(self, isTagged(k) as Refinement<E, Extract<E, { _tag: K }>>, f) as any)
-
-/**
- * Transform the full `MicroCause` object of the given `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category error handling
- */
-export const mapErrorCause: {
-  <E, E2>(f: (e: MicroCause<E>) => MicroCause<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>
-  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: MicroCause<E>) => MicroCause<E2>): Micro<A, E2, R>
-} = dual(
-  2,
-  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: MicroCause<E>) => MicroCause<E2>): Micro<A, E2, R> =>
-    catchAllCause(self, (cause) => failCause(f(cause)))
-)
-
-/**
- * Transform any expected errors of the given `Micro` effect.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const mapError: {
-  <E, E2>(f: (e: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>
-  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: E) => E2): Micro<A, E2, R>
-} = dual(
-  2,
-  <A, E, R, E2>(self: Micro<A, E, R>, f: (e: E) => E2): Micro<A, E2, R> => catchAll(self, (error) => fail(f(error)))
-)
-
-/**
- * Elevate any expected errors of the given `Micro` effect to unexpected errors,
- * resulting in an error type of `never`.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const orDie = <A, E, R>(self: Micro<A, E, R>): Micro<A, never, R> => catchAll(self, die)
-
-/**
- * Recover from all errors by succeeding with the given value.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const orElseSucceed: {
-  <B>(f: LazyArg<B>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | B, never, R>
-  <A, E, R, B>(self: Micro<A, E, R>, f: LazyArg<B>): Micro<A | B, never, R>
-} = dual(
-  2,
-  <A, E, R, B>(self: Micro<A, E, R>, f: LazyArg<B>): Micro<A | B, never, R> => catchAll(self, (_) => sync(f))
-)
-
-/**
- * Ignore any expected errors of the given `Micro` effect, returning `void`.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const ignore = <A, E, R>(self: Micro<A, E, R>): Micro<void, never, R> =>
-  matchEffect(self, { onFailure: (_) => void_, onSuccess: (_) => void_ })
-
-/**
- * Ignore any expected errors of the given `Micro` effect, returning `void`.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const ignoreLogged = <A, E, R>(self: Micro<A, E, R>): Micro<void, never, R> =>
-  matchEffect(self, {
-    // eslint-disable-next-line no-console
-    onFailure: (error) => sync(() => console.error(error)),
-    onSuccess: (_) => void_
-  })
-
-/**
- * Replace the success value of the given `Micro` effect with an `Option`,
- * wrapping the success value in `Some` and returning `None` if the effect fails
- * with an expected error.
- *
- * @since 3.4.0
- * @experimental
- * @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 })
-
-/**
- * Replace the success value of the given `Micro` effect with an `Either`,
- * wrapping the success value in `Right` and wrapping any expected errors with
- * a `Left`.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const either = <A, E, R>(self: Micro<A, E, R>): Micro<Either.Either<A, E>, never, R> =>
-  match(self, { onFailure: Either.left, onSuccess: Either.right })
-
-/**
- * Retry the given `Micro` effect using the provided options.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const retry: {
-  <A, E>(
-    options?: {
-      while?: Predicate<E> | undefined
-      times?: number | undefined
-      schedule?: MicroSchedule | undefined
-    } | undefined
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(
-    self: Micro<A, E, R>,
-    options?: {
-      while?: Predicate<E> | undefined
-      times?: number | undefined
-      schedule?: MicroSchedule | undefined
-    } | undefined
-  ): Micro<A, E, R>
-} = dual((args) => isMicro(args[0]), <A, E, R>(
-  self: Micro<A, E, R>,
-  options?: {
-    while?: Predicate<E> | undefined
-    times?: number | undefined
-    schedule?: MicroSchedule | undefined
-  } | undefined
-): Micro<A, E, R> =>
-  repeatExit(self, {
-    ...options,
-    while: (exit) =>
-      exit._tag === "Failure" && exit.cause._tag === "Fail" &&
-      (options?.while === undefined || options.while(exit.cause.error))
-  }))
-
-/**
- * Add a stack trace to any failures that occur in the effect. The trace will be
- * added to the `traces` field of the `MicroCause` object.
- *
- * @since 3.4.0
- * @experimental
- * @category error handling
- */
-export const withTrace: {
-  (name: string): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>
-} = function() {
-  const prevLimit = globalThis.Error.stackTraceLimit
-  globalThis.Error.stackTraceLimit = 2
-  const error = new globalThis.Error()
-  globalThis.Error.stackTraceLimit = prevLimit
-  function generate(name: string, cause: MicroCause<any>) {
-    const stack = error.stack
-    if (!stack) {
-      return cause
-    }
-    const line = stack.split("\n")[2]?.trim().replace(/^at /, "")
-    if (!line) {
-      return cause
-    }
-    const lineMatch = line.match(/\((.*)\)$/)
-    return causeWithTrace(cause, `at ${name} (${lineMatch ? lineMatch[1] : line})`)
-  }
-  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])
-  }
-  return f(arguments[0])
-} as any
-
-// ----------------------------------------------------------------------------
-// pattern matching
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.4.6
- * @experimental
- * @category pattern matching
- */
-export const matchCauseEffect: {
-  <E, A2, E2, R2, A, A3, E3, R3>(options: {
-    readonly onFailure: (cause: MicroCause<E>) => Micro<A2, E2, R2>
-    readonly onSuccess: (a: A) => Micro<A3, E3, R3>
-  }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, E2 | E3, R2 | R3 | R>
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (cause: MicroCause<E>) => Micro<A2, E2, R2>
-      readonly onSuccess: (a: A) => Micro<A3, E3, R3>
-    }
-  ): Micro<A2 | A3, E2 | E3, R2 | R3 | R>
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Micro<A, E, R>,
-    options: {
-      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> => {
-    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: MicroFiberImpl): Primitive {
-    fiber._stack.push(this)
-    return this[args]
-  }
-})
-
-/**
- * @since 3.4.6
- * @experimental
- * @category pattern matching
- */
-export const matchCause: {
-  <E, A2, A, A3>(
-    options: {
-      readonly onFailure: (cause: MicroCause<E>) => A2
-      readonly onSuccess: (a: A) => A3
-    }
-  ): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>
-  <A, E, R, A2, A3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (cause: MicroCause<E>) => A2
-      readonly onSuccess: (a: A) => A3
-    }
-  ): Micro<A2 | A3, never, R>
-} = dual(
-  2,
-  <A, E, R, A2, A3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (cause: MicroCause<E>) => A2
-      readonly onSuccess: (a: A) => A3
-    }
-  ): Micro<A2 | A3, never, R> =>
-    matchCauseEffect(self, {
-      onFailure: (cause) => sync(() => options.onFailure(cause)),
-      onSuccess: (value) => sync(() => options.onSuccess(value))
-    })
-)
-
-/**
- * @since 3.4.6
- * @experimental
- * @category pattern matching
- */
-export const matchEffect: {
-  <E, A2, E2, R2, A, A3, E3, R3>(
-    options: {
-      readonly onFailure: (e: E) => Micro<A2, E2, R2>
-      readonly onSuccess: (a: A) => Micro<A3, E3, R3>
-    }
-  ): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, E2 | E3, R2 | R3 | R>
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (e: E) => Micro<A2, E2, R2>
-      readonly onSuccess: (a: A) => Micro<A3, E3, R3>
-    }
-  ): Micro<A2 | A3, E2 | E3, R2 | R3 | R>
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2, A3, E3, R3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (e: E) => Micro<A2, E2, R2>
-      readonly onSuccess: (a: A) => Micro<A3, E3, R3>
-    }
-  ): Micro<A2 | A3, E2 | E3, R2 | R3 | R> =>
-    matchCauseEffect(self, {
-      onFailure: (cause) => cause._tag === "Fail" ? options.onFailure(cause.error) : failCause(cause),
-      onSuccess: options.onSuccess
-    })
-)
-
-/**
- * @since 3.4.0
- * @experimental
- * @category pattern matching
- */
-export const match: {
-  <E, A2, A, A3>(
-    options: {
-      readonly onFailure: (error: E) => A2
-      readonly onSuccess: (value: A) => A3
-    }
-  ): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>
-  <A, E, R, A2, A3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (error: E) => A2
-      readonly onSuccess: (value: A) => A3
-    }
-  ): Micro<A2 | A3, never, R>
-} = dual(
-  2,
-  <A, E, R, A2, A3>(
-    self: Micro<A, E, R>,
-    options: {
-      readonly onFailure: (error: E) => A2
-      readonly onSuccess: (value: A) => A3
-    }
-  ): Micro<A2 | A3, never, R> =>
-    matchEffect(self, {
-      onFailure: (error) => sync(() => options.onFailure(error)),
-      onSuccess: (value) => sync(() => options.onSuccess(value))
-    })
-)
-
-// ----------------------------------------------------------------------------
-// delays & timeouts
-// ----------------------------------------------------------------------------
-
-/**
- * Create a `Micro` effect that will sleep for the specified duration.
- *
- * @since 3.4.0
- * @experimental
- * @category delays & timeouts
- */
-export const sleep = (millis: number): Micro<void> =>
-  async((resume) => {
-    const timeout = setTimeout(() => {
-      resume(void_)
-    }, millis)
-    return sync(() => {
-      clearTimeout(timeout)
-    })
-  })
-
-/**
- * Returns an effect that will delay the execution of this effect by the
- * specified duration.
- *
- * @since 3.4.0
- * @experimental
- * @category delays & timeouts
- */
-export const delay: {
-  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E, R>
-} = dual(
-  2,
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E, R> => andThen(sleep(millis), self)
-)
-
-/**
- * Returns an effect that will timeout this effect, that will execute the
- * fallback effect if the timeout elapses before the effect has produced a value.
- *
- * If the timeout elapses, the running effect will be safely interrupted.
- *
- * @since 3.4.0
- * @experimental
- * @category delays & timeouts
- */
-export const timeoutOrElse: {
-  <A2, E2, R2>(options: {
-    readonly duration: number
-    readonly onTimeout: LazyArg<Micro<A2, E2, R2>>
-  }): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, options: {
-    readonly duration: number
-    readonly onTimeout: LazyArg<Micro<A2, E2, R2>>
-  }): Micro<A | A2, E | E2, R | R2>
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, options: {
-    readonly duration: number
-    readonly onTimeout: LazyArg<Micro<A2, E2, R2>>
-  }): Micro<A | A2, E | E2, R | R2> =>
-    raceFirst(self, andThen(interruptible(sleep(options.duration)), options.onTimeout))
-)
-
-/**
- * Returns an effect that will timeout this effect, that will fail with a
- * `TimeoutException` if the timeout elapses before the effect has produced a
- * value.
- *
- * If the timeout elapses, the running effect will be safely interrupted.
- *
- * @since 3.4.0
- * @experimental
- * @category delays & timeouts
- */
-export const timeout: {
-  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | TimeoutException, R>
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E | TimeoutException, R>
-} = dual(
-  2,
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E | TimeoutException, R> =>
-    timeoutOrElse(self, { duration: millis, onTimeout: () => fail(new TimeoutException()) })
-)
-
-/**
- * Returns an effect that will timeout this effect, succeeding with a `None`
- * if the timeout elapses before the effect has produced a value; and `Some` of
- * the produced value otherwise.
- *
- * If the timeout elapses, the running effect will be safely interrupted.
- *
- * @since 3.4.0
- * @experimental
- * @category delays & timeouts
- */
-export const timeoutOption: {
-  (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R>
-} = dual(
-  2,
-  <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R> =>
-    raceFirst(
-      asSome(self),
-      as(interruptible(sleep(millis)), Option.none())
-    )
-)
-
-// ----------------------------------------------------------------------------
-// resources & finalization
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const MicroScopeTypeId: unique symbol = Symbol.for("effect/Micro/MicroScope")
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export type MicroScopeTypeId = typeof MicroScopeTypeId
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export interface MicroScope {
-  readonly [MicroScopeTypeId]: MicroScopeTypeId
-  readonly addFinalizer: (finalizer: (exit: MicroExit<unknown, unknown>) => Micro<void>) => Micro<void>
-  readonly fork: Micro<MicroScope.Closeable>
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export declare namespace MicroScope {
-  /**
-   * @since 3.4.0
-   * @experimental
-   * @category resources & finalization
-   */
-  export interface Closeable extends MicroScope {
-    readonly close: (exit: MicroExit<any, any>) => Micro<void>
-  }
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const MicroScope: Context.Tag<MicroScope, MicroScope> = Context.GenericTag<MicroScope>("effect/Micro/MicroScope")
-
-class MicroScopeImpl implements MicroScope.Closeable {
-  readonly [MicroScopeTypeId]: MicroScopeTypeId
-  state: {
-    readonly _tag: "Open"
-    readonly finalizers: Set<(exit: MicroExit<any, any>) => Micro<void>>
-  } | {
-    readonly _tag: "Closed"
-    readonly exit: MicroExit<any, any>
-  } = { _tag: "Open", finalizers: new Set() }
-
-  constructor() {
-    this[MicroScopeTypeId] = MicroScopeTypeId
-  }
-
-  unsafeAddFinalizer(finalizer: (exit: MicroExit<any, any>) => Micro<void>): void {
-    if (this.state._tag === "Open") {
-      this.state.finalizers.add(finalizer)
-    }
-  }
-  addFinalizer(finalizer: (exit: MicroExit<any, any>) => Micro<void>): Micro<void> {
-    return suspend(() => {
-      if (this.state._tag === "Open") {
-        this.state.finalizers.add(finalizer)
-        return void_
-      }
-      return finalizer(this.state.exit)
-    })
-  }
-  unsafeRemoveFinalizer(finalizer: (exit: MicroExit<any, any>) => Micro<void>): void {
-    if (this.state._tag === "Open") {
-      this.state.finalizers.delete(finalizer)
-    }
-  }
-  close(microExit: MicroExit<any, any>): Micro<void> {
-    return suspend(() => {
-      if (this.state._tag === "Open") {
-        const finalizers = Array.from(this.state.finalizers).reverse()
-        this.state = { _tag: "Closed", exit: microExit }
-        return flatMap(
-          forEach(finalizers, (finalizer) => exit(finalizer(microExit))),
-          exitVoidAll
-        )
-      }
-      return void_
-    })
-  }
-  get fork() {
-    return sync(() => {
-      const newScope = new MicroScopeImpl()
-      if (this.state._tag === "Closed") {
-        newScope.state = this.state
-        return newScope
-      }
-      function fin(exit: MicroExit<any, any>) {
-        return newScope.close(exit)
-      }
-      this.state.finalizers.add(fin)
-      newScope.unsafeAddFinalizer((_) => sync(() => this.unsafeRemoveFinalizer(fin)))
-      return newScope
-    })
-  }
-}
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const scopeMake: Micro<MicroScope.Closeable> = sync(() => new MicroScopeImpl())
-
-/**
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const scopeUnsafeMake = (): MicroScope.Closeable => new MicroScopeImpl()
-
-/**
- * Access the current `MicroScope`.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const scope: Micro<MicroScope, never, MicroScope> = service(MicroScope)
-
-/**
- * Provide a `MicroScope` to an effect.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const provideScope: {
-  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, MicroScope>>
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<A, E, Exclude<R, MicroScope>>
-} = dual(
-  2,
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<A, E, Exclude<R, MicroScope>> =>
-    provideService(self, MicroScope, scope)
-)
-
-/**
- * Provide a `MicroScope` to the given effect, closing it after the effect has
- * finished executing.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const scoped = <A, E, R>(self: Micro<A, E, R>): Micro<A, E, Exclude<R, MicroScope>> =>
-  suspend(() => {
-    const scope = new MicroScopeImpl()
-    return onExit(provideService(self, MicroScope, scope), (exit) => scope.close(exit))
-  })
-
-/**
- * Create a resource with a cleanup `Micro` effect, ensuring the cleanup is
- * executed when the `MicroScope` is closed.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const acquireRelease = <A, E, R>(
-  acquire: Micro<A, E, R>,
-  release: (a: A, exit: MicroExit<unknown, unknown>) => Micro<void>
-): Micro<A, E, R | MicroScope> =>
-  uninterruptible(flatMap(
-    scope,
-    (scope) => tap(acquire, (a) => scope.addFinalizer((exit) => release(a, exit)))
-  ))
-
-/**
- * Add a finalizer to the current `MicroScope`.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const addFinalizer = (
-  finalizer: (exit: MicroExit<unknown, unknown>) => Micro<void>
-): Micro<void, never, MicroScope> => flatMap(scope, (scope) => scope.addFinalizer(finalizer))
-
-/**
- * When the `Micro` effect is completed, run the given finalizer effect with the
- * `MicroExit` of the executed effect.
- *
- * @since 3.4.6
- * @experimental
- * @category resources & finalization
- */
-export const onExit: {
-  <A, E, XE, XR>(
-    f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR>(
-    self: Micro<A, E, R>,
-    f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR>
-} = dual(
-  2,
-  <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> =>
-    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: {
-  <XE, XR>(
-    finalizer: Micro<void, XE, XR>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR>(
-    self: Micro<A, E, R>,
-    finalizer: Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR>
-} = 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)
-)
-
-/**
- * When the `Micro` effect is completed, run the given finalizer effect if it
- * matches the specified predicate.
- *
- * @since 3.4.6
- * @experimental
- * @category resources & finalization
- */
-export const onExitIf: {
-  <A, E, XE, XR, B extends MicroExit<A, E>>(
-    refinement: Refinement<MicroExit<A, E>, B>,
-    f: (exit: B) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, XE, XR>(
-    predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>,
-    f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR, B extends MicroExit<A, E>>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<MicroExit<A, E>, B>,
-    f: (exit: B) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR>(
-    self: Micro<A, E, R>,
-    predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>,
-    f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR>
-} = dual(
-  3,
-  <A, E, R, XE, XR, B extends MicroExit<A, E>>(
-    self: Micro<A, E, R>,
-    refinement: Refinement<MicroExit<A, E>, B>,
-    f: (exit: B) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR> => onExit(self, (exit) => (refinement(exit) ? f(exit) : exitVoid))
-)
-
-/**
- * When the `Micro` effect fails, run the given finalizer effect with the
- * `MicroCause` of the executed effect.
- *
- * @since 3.4.6
- * @experimental
- * @category resources & finalization
- */
-export const onError: {
-  <A, E, XE, XR>(
-    f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>
-  ): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR>(
-    self: Micro<A, E, R>,
-    f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>
-  ): Micro<A, E | XE, R | XR>
-} = dual(
-  2,
-  <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.cause))
-)
-
-/**
- * If this `Micro` effect is aborted, run the finalizer effect.
- *
- * @since 3.4.6
- * @experimental
- * @category resources & finalization
- */
-export const onInterrupt: {
-  <XE, XR>(
-    finalizer: Micro<void, XE, XR>
-  ): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>
-  <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>
-} = dual(
-  2,
-  <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR> =>
-    onExitIf(self, exitIsInterrupt, (_) => finalizer)
-)
-
-/**
- * Acquire a resource, use it, and then release the resource when the `use`
- * effect has completed.
- *
- * @since 3.4.0
- * @experimental
- * @category resources & finalization
- */
-export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
-  acquire: Micro<Resource, E, R>,
-  use: (a: Resource) => Micro<A, E2, R2>,
-  release: (a: Resource, exit: MicroExit<A, E2>) => Micro<void, E3, R3>
-): Micro<A, E | E2 | E3, R | R2 | R3> =>
-  uninterruptibleMask((restore) =>
-    flatMap(
-      acquire,
-      (a) =>
-        flatMap(
-          exit(restore(use(a))),
-          (exit) => andThen(release(a, exit), exit)
-        )
-    )
-  )
-
-// ----------------------------------------------------------------------------
-// interruption
-// ----------------------------------------------------------------------------
-
-/**
- * Abort the current `Micro` effect.
- *
- * @since 3.4.6
- * @experimental
- * @category interruption
- */
-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> =>
-  withMicroFiber((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
-    }
-  }
-})
-
-/**
- * Flag the effect as interruptible, which means that when the effect is
- * interrupted, it will be interrupted immediately.
- *
- * @since 3.4.0
- * @experimental
- * @category flags
- */
-export const interruptible = <A, E, R>(
-  self: Micro<A, E, R>
-): Micro<A, E, R> =>
-  withMicroFiber((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
- * effect from being aborted.
- *
- * You can use the `restore` function to restore a `Micro` effect to the
- * interruptibility state before the `uninterruptibleMask` was applied.
- *
- * @example
- * ```ts
- * import * as Micro from "effect/Micro"
- *
- * Micro.uninterruptibleMask((restore) =>
- *   Micro.sleep(1000).pipe( // uninterruptible
- *     Micro.andThen(restore(Micro.sleep(1000))) // interruptible
- *   )
- * )
- * ```
- *
- * @since 3.4.0
- * @experimental
- * @category interruption
- */
-export const uninterruptibleMask = <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> =>
-  withMicroFiber((fiber) => {
-    if (!fiber.interruptible) return f(identity)
-    fiber.interruptible = false
-    fiber._stack.push(setInterruptible(true))
-    return f(interruptible)
-  })
-
-// ========================================================================
-// collecting & elements
-// ========================================================================
-
-/**
- * @since 3.4.0
- * @experimental
- */
-export declare namespace All {
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type MicroAny = Micro<any, any, any>
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type ReturnIterable<T extends Iterable<MicroAny>, Discard extends boolean> = [T] extends
-    [Iterable<Micro<infer A, infer E, infer R>>] ? Micro<
-      Discard extends true ? void : Array<A>,
-      E,
-      R
-    >
-    : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type ReturnTuple<T extends ReadonlyArray<unknown>, Discard extends boolean> = Micro<
-    Discard extends true ? void
-      : T[number] extends never ? []
-      : { -readonly [K in keyof T]: T[K] extends Micro<infer _A, infer _E, infer _R> ? _A : never },
-    T[number] extends never ? never
-      : T[number] extends Micro<infer _A, infer _E, infer _R> ? _E
-      : never,
-    T[number] extends never ? never
-      : T[number] extends Micro<infer _A, infer _E, infer _R> ? _R
-      : never
-  > extends infer X ? X : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type ReturnObject<T, Discard extends boolean> = [T] extends [{ [K: string]: MicroAny }] ? Micro<
-      Discard extends true ? void :
-        { -readonly [K in keyof T]: [T[K]] extends [Micro<infer _A, infer _E, infer _R>] ? _A : never },
-      keyof T extends never ? never
-        : T[keyof T] extends Micro<infer _A, infer _E, infer _R> ? _E
-        : never,
-      keyof T extends never ? never
-        : T[keyof T] extends Micro<infer _A, infer _E, infer _R> ? _R
-        : never
-    >
-    : never
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type IsDiscard<A> = [Extract<A, { readonly discard: true }>] extends [never] ? false : true
-
-  /**
-   * @since 3.4.0
-   * @experimental
-   */
-  export type Return<
-    Arg extends Iterable<MicroAny> | Record<string, MicroAny>,
-    O extends NoExcessProperties<{
-      readonly concurrency?: Concurrency | undefined
-      readonly discard?: boolean | undefined
-    }, O>
-  > = [Arg] extends [ReadonlyArray<MicroAny>] ? ReturnTuple<Arg, IsDiscard<O>>
-    : [Arg] extends [Iterable<MicroAny>] ? ReturnIterable<Arg, IsDiscard<O>>
-    : [Arg] extends [Record<string, MicroAny>] ? ReturnObject<Arg, IsDiscard<O>>
-    : never
-}
-
-/**
- * Runs all the provided effects in sequence respecting the structure provided in input.
- *
- * Supports multiple arguments, a single argument tuple / array or record / struct.
- *
- * @since 3.4.0
- * @experimental
- * @category collecting & elements
- */
-export const all = <
-  const Arg extends Iterable<Micro<any, any, any>> | Record<string, Micro<any, any, any>>,
-  O extends NoExcessProperties<{
-    readonly concurrency?: Concurrency | undefined
-    readonly discard?: boolean | undefined
-  }, O>
->(arg: Arg, options?: O): All.Return<Arg, O> => {
-  if (Array.isArray(arg) || isIterable(arg)) {
-    return (forEach as any)(arg, identity, options)
-  } else if (options?.discard) {
-    return (forEach as any)(Object.values(arg), identity, options)
-  }
-  return suspend(() => {
-    const out: Record<string, unknown> = {}
-    return as(
-      forEach(Object.entries(arg), ([key, effect]) =>
-        map(effect, (value) => {
-          out[key] = value
-        }), {
-        discard: true,
-        concurrency: options?.concurrency
-      }),
-      out
-    )
-  }) 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.
- *
- * If the `discard` option is set to `true`, the results will be discarded and
- * the effect will return `void`.
- *
- * The `concurrency` option can be set to control how many effects are run
- * concurrently. By default, the effects are run sequentially.
- *
- * @since 3.4.0
- * @experimental
- * @category collecting & elements
- */
-export const forEach: {
-  <A, B, E, R>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options?: {
-    readonly concurrency?: Concurrency | undefined
-    readonly discard?: false | undefined
-  }): Micro<Array<B>, E, R>
-  <A, B, E, R>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options: {
-    readonly concurrency?: Concurrency | undefined
-    readonly discard: true
-  }): Micro<void, E, R>
-} = <
-  A,
-  B,
-  E,
-  R
->(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options?: {
-  readonly concurrency?: Concurrency | undefined
-  readonly discard?: boolean | undefined
-}): Micro<any, E, R> =>
-  withMicroFiber((parent) => {
-    const concurrencyOption = options?.concurrency === "inherit"
-      ? parent.getRef(CurrentConcurrency)
-      : options?.concurrency ?? 1
-    const concurrency = concurrencyOption === "unbounded"
-      ? Number.POSITIVE_INFINITY
-      : Math.max(1, concurrencyOption)
-
-    const items = Arr.fromIterable(iterable)
-    let length = items.length
-    if (length === 0) {
-      return options?.discard ? void_ : succeed([])
-    }
-
-    const out: Array<B> | undefined = options?.discard ? undefined : new Array(length)
-    let index = 0
-
-    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<MicroFiber<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
-              }
-              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
-      }
-      pump()
-
-      return suspend(() => {
-        interrupted = true
-        index = length
-        return fiberInterruptAll(fibers)
-      })
-    })
-  })
-
-/**
- * Effectfully filter the elements of the provided iterable.
- *
- * Use the `concurrency` option to control how many elements are processed
- * concurrently.
- *
- * @since 3.4.0
- * @experimental
- * @category collecting & elements
- */
-export const filter = <A, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>) => Micro<boolean, E, R>, options?: {
-  readonly concurrency?: Concurrency | undefined
-  readonly negate?: boolean | undefined
-}): Micro<Array<A>, E, R> =>
-  filterMap(iterable, (a) =>
-    map(f(a), (pass) => {
-      pass = options?.negate ? !pass : pass
-      return pass ? Option.some(a) : Option.none()
-    }), options)
-
-/**
- * Effectfully filter the elements of the provided iterable.
- *
- * Use the `concurrency` option to control how many elements are processed
- * concurrently.
- *
- * @since 3.4.0
- * @experimental
- * @category collecting & elements
- */
-export const filterMap = <A, B, E, R>(
-  iterable: Iterable<A>,
-  f: (a: NoInfer<A>) => Micro<Option.Option<B>, E, R>,
-  options?: {
-    readonly concurrency?: Concurrency | undefined
-  }
-): Micro<Array<B>, E, R> =>
-  suspend(() => {
-    const out: Array<B> = []
-    return as(
-      forEach(iterable, (a) =>
-        map(f(a), (o) => {
-          if (o._tag === "Some") {
-            out.push(o.value)
-          }
-        }), {
-        discard: true,
-        concurrency: options?.concurrency
-      }),
-      out
-    )
-  })
-
-// ----------------------------------------------------------------------------
-// do notation
-// ----------------------------------------------------------------------------
-
-/**
- * Start a do notation block.
- *
- * @since 3.4.0
- * @experimental
- * @category do notation
- */
-export const Do: Micro<{}> = succeed({})
-
-/**
- * Bind the success value of this `Micro` effect to the provided name.
- *
- * @since 3.4.0
- * @experimental
- * @category do notation
- */
-export const bindTo: {
-  <N extends string>(name: N): <A, E, R>(self: Micro<A, E, R>) => Micro<{ [K in N]: A }, E, R>
-  <A, E, R, N extends string>(self: Micro<A, E, R>, name: N): Micro<{ [K in N]: A }, E, R>
-} = doNotation.bindTo<MicroTypeLambda>(map)
-
-/**
- * Bind the success value of this `Micro` effect to the provided name.
- *
- * @since 3.4.0
- * @experimental
- * @category do notation
- */
-export const bind: {
-  <N extends string, A extends Record<string, any>, B, E2, R2>(
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
-  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(
-    self: Micro<A, E, R>,
-    name: N,
-    f: (a: NoInfer<A>) => Micro<B, E2, R2>
-  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
-} = doNotation.bind<MicroTypeLambda>(map, flatMap)
-
-const let_: {
-  <N extends string, A extends Record<string, any>, B>(
-    name: N,
-    f: (a: NoInfer<A>) => B
-  ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
-  <A extends Record<string, any>, E, R, B, N extends string>(
-    self: Micro<A, E, R>,
-    name: N,
-    f: (a: NoInfer<A>) => B
-  ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
-} = doNotation.let_<MicroTypeLambda>(map)
-
-export {
-  /**
-   * Bind the result of a synchronous computation to the given name.
-   *
-   * @since 3.4.0
-   * @experimental
-   * @category do notation
-   */
-  let_ as let
-}
-
-// ----------------------------------------------------------------------------
-// fibers & forking
-// ----------------------------------------------------------------------------
-
-/**
- * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
- * aborted.
- *
- * When the parent `Micro` finishes, this `Micro` will be aborted.
- *
- * @since 3.4.0
- * @experimental
- * @category fiber & forking
- */
-export const fork = <A, E, R>(
-  self: Micro<A, E, R>
-): Micro<MicroFiber<A, E>, never, R> =>
-  withMicroFiber((fiber) => {
-    fiberMiddleware.interruptChildren ??= fiberInterruptChildren
-    return succeed(unsafeFork(fiber, self))
-  })
-
-const unsafeFork = <FA, FE, A, E, R>(
-  parent: MicroFiberImpl<FA, FE>,
-  effect: Micro<A, E, R>,
-  immediate = false,
-  daemon = false
-): MicroFiber<A, E> => {
-  const child = new MicroFiberImpl<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 `MicroFiber` that can be awaited, joined, or
- * aborted.
- *
- * It will not be aborted when the parent `Micro` finishes.
- *
- * @since 3.4.0
- * @experimental
- * @category fiber & forking
- */
-export const forkDaemon = <A, E, R>(
-  self: Micro<A, E, R>
-): Micro<MicroFiber<A, E>, never, R> => withMicroFiber((fiber) => succeed(unsafeFork(fiber, self, false, true)))
-
-/**
- * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
- * aborted.
- *
- * The lifetime of the handle will be attached to the provided `MicroScope`.
- *
- * @since 3.4.0
- * @experimental
- * @category fiber & forking
- */
-export const forkIn: {
-  (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<MicroFiber<A, E>, never, R>
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R>
-} = dual(
-  2,
-  <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<MicroFiber<A, E>, never, R> =>
-    uninterruptibleMask((restore) =>
-      flatMap(scope.fork, (scope) =>
-        tap(
-          restore(forkDaemon(onExit(self, (exit) => scope.close(exit)))),
-          (fiber) => scope.addFinalizer((_) => fiberInterrupt(fiber))
-        ))
-    )
-)
-
-/**
- * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or
- * aborted.
- *
- * The lifetime of the handle will be attached to the current `MicroScope`.
- *
- * @since 3.4.0
- * @experimental
- * @category fiber & forking
- */
-export const forkScoped = <A, E, R>(self: Micro<A, E, R>): Micro<MicroFiber<A, E>, never, R | MicroScope> =>
-  flatMap(scope, (scope) => forkIn(self, scope))
-
-// ----------------------------------------------------------------------------
-// execution
-// ----------------------------------------------------------------------------
-
-/**
- * Execute the `Micro` effect and return a `MicroFiber` that can be awaited, joined,
- * or aborted.
- *
- * You can listen for the result by adding an observer using the handle's
- * `addObserver` method.
- *
- * @example
- * ```ts
- * import * as Micro from "effect/Micro"
- *
- * const handle = Micro.succeed(42).pipe(
- *   Micro.delay(1000),
- *   Micro.runFork
- * )
- *
- * handle.addObserver((exit) => {
- *   console.log(exit)
- * })
- * ```
- *
- * @since 3.4.0
- * @experimental
- * @category execution
- */
-export const runFork = <A, E>(
-  effect: Micro<A, E>,
-  options?: {
-    readonly signal?: AbortSignal | undefined
-    readonly scheduler?: MicroScheduler | undefined
-  } | undefined
-): MicroFiberImpl<A, E> => {
-  const fiber = new MicroFiberImpl<A, E>(CurrentScheduler.context(
-    options?.scheduler ?? new MicroSchedulerDefault()
-  ))
-  fiber.evaluate(effect as any)
-  if (options?.signal) {
-    if (options.signal.aborted) {
-      fiber.unsafeInterrupt()
-    } else {
-      const abort = () => fiber.unsafeInterrupt()
-      options.signal.addEventListener("abort", abort, { once: true })
-      fiber.addObserver(() => options.signal!.removeEventListener("abort", abort))
-    }
-  }
-  return fiber
-}
-
-/**
- * Execute the `Micro` effect and return a `Promise` that resolves with the
- * `MicroExit` of the computation.
- *
- * @since 3.4.6
- * @experimental
- * @category execution
- */
-export const runPromiseExit = <A, E>(
-  effect: Micro<A, E>,
-  options?: {
-    readonly signal?: AbortSignal | undefined
-    readonly scheduler?: MicroScheduler | undefined
-  } | undefined
-): Promise<MicroExit<A, E>> =>
-  new Promise((resolve, _reject) => {
-    const handle = runFork(effect, options)
-    handle.addObserver(resolve)
-  })
-
-/**
- * Execute the `Micro` effect and return a `Promise` that resolves with the
- * successful value of the computation.
- *
- * @since 3.4.0
- * @experimental
- * @category execution
- */
-export const runPromise = <A, E>(
-  effect: Micro<A, E>,
-  options?: {
-    readonly signal?: AbortSignal | undefined
-    readonly scheduler?: MicroScheduler | undefined
-  } | undefined
-): Promise<A> =>
-  runPromiseExit(effect, options).then((exit) => {
-    if (exit._tag === "Failure") {
-      throw exit.cause
-    }
-    return exit.value
-  })
-
-/**
- * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`.
- *
- * If any asynchronous effects are encountered, the function will return a
- * `CauseDie` containing the `MicroFiber`.
- *
- * @since 3.4.6
- * @experimental
- * @category execution
- */
-export const runSyncExit = <A, E>(effect: Micro<A, E>): MicroExit<A, E> => {
-  const scheduler = new MicroSchedulerDefault()
-  const fiber = runFork(effect, { scheduler })
-  scheduler.flush()
-  return fiber._exit ?? exitDie(fiber)
-}
-
-/**
- * Attempt to execute the `Micro` effect synchronously and return the success
- * value.
- *
- * @since 3.4.0
- * @experimental
- * @category execution
- */
-export const runSync = <A, E>(effect: Micro<A, E>): A => {
-  const exit = runSyncExit(effect)
-  if (exit._tag === "Failure") throw exit.cause
-  return exit.value
-}
-
-// ----------------------------------------------------------------------------
-// Errors
-// ----------------------------------------------------------------------------
-
-/**
- * @since 3.4.0
- * @experimental
- * @category errors
- */
-export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
-  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>
-  [Symbol.iterator](): MicroIterator<Micro<never, this, never>>
-}
-
-const YieldableError: new(message?: string) => YieldableError = (function() {
-  class YieldableError extends globalThis.Error {}
-  // @effect-diagnostics-next-line floatingEffect:off
-  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](this: Error): string {
-      const stack = this.stack
-      if (stack) {
-        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
-      }
-      return this.toString()
-    }
-  })
-  return YieldableError as any
-})()
-
-/**
- * @since 3.4.0
- * @experimental
- * @category errors
- */
-export const Error: new<A extends Record<string, any> = {}>(
-  args: Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
-) => YieldableError & Readonly<A> = (function() {
-  return class extends YieldableError {
-    constructor(args: any) {
-      super()
-      if (args) {
-        Object.assign(this, args)
-      }
-    }
-  } as any
-})()
-
-/**
- * @since 3.4.0
- * @experimental
- * @category errors
- */
-export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any> = {}>(
-  args: Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
-) => YieldableError & { readonly _tag: Tag } & Readonly<A> => {
-  class Base extends Error<{}> {
-    readonly _tag = tag
-  }
-  ;(Base.prototype as any).name = tag
-  return Base as any
-}
-
-/**
- * Represents a checked exception which occurs when an expected element was
- * unable to be found.
- *
- * @since 3.4.4
- * @experimental
- * @category errors
- */
-export class NoSuchElementException extends TaggedError("NoSuchElementException")<{ message?: string | undefined }> {}
-
-/**
- * Represents a checked exception which occurs when a timeout occurs.
- *
- * @since 3.4.4
- * @experimental
- * @category errors
- */
-export class TimeoutException extends TaggedError("TimeoutException") {}