effect 3.3.5 → 3.4.0

package/dist/cjs/Micro.js

@@ -0,0 +1,2383 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchFailureMicro = exports.matchFailure = exports.match = exports.mapFailure = exports.mapError = exports.map = exports.make = exports.locally = exports.let = exports.isMicro = exports.isHandle = exports.interruptible = exports.ignoreLogged = exports.ignore = exports.getEnvRef = exports.gen = exports.fromResultSync = exports.fromResult = exports.fromOption = exports.fromEither = exports.forkScoped = exports.forkIn = exports.forkDaemon = exports.fork = exports.forever = exports.forEach = exports.flip = exports.flatten = exports.flatMap = exports.filterOrFailWith = exports.filterOrFail = exports.filterMap = exports.filter = exports.failureWithTrace = exports.failureSquash = exports.failureIsUnexpected = exports.failureIsExpected = exports.failureIsAborted = exports.failWithSync = exports.failWith = exports.failSync = exports.fail = exports.envUnsafeMakeEmpty = exports.envSet = exports.envRefMake = exports.envMutate = exports.envMake = exports.envGet = exports.ensuring = exports.either = exports.die = exports.delayWithRecurs = exports.delayWithMaxElapsed = exports.delayWithMax = exports.delaySpaced = exports.delayExponential = exports.delay = exports.currentMaxDepthBeforeYield = exports.currentContext = exports.currentConcurrency = exports.currentAbortSignal = exports.currentAbortController = exports.context = exports.catchUnexpected = exports.catchTag = exports.catchIf = exports.catchFailureIf = exports.catchFailure = exports.catchExpected = exports.bindTo = exports.bind = exports.async = exports.asVoid = exports.asSome = exports.asResult = exports.as = exports.andThen = exports.all = exports.addFinalizer = exports.acquireUseRelease = exports.acquireRelease = exports.abort = exports.TypeId = exports.TaggedError = exports.ResultSuccess = exports.ResultFailWith = exports.ResultFailUnexpected = exports.ResultFail = exports.ResultAborted = exports.MicroScopeTypeId = exports.MicroScope = exports.HandleTypeId = exports.FailureUnexpected = exports.FailureTypeId = exports.FailureExpected = exports.FailureAborted = exports.Error = exports.EnvTypeId = exports.EnvRefTypeId = exports.Do = void 0;
+exports.zip = exports.yieldNow = exports.yieldFlush = exports.withTrace = exports.withConcurrency = exports.when = exports.void = exports.uninterruptibleMask = exports.uninterruptible = exports.tryPromise = exports.try = exports.timeoutOrElse = exports.timeout = exports.tapUnexpected = exports.tapFailureIf = exports.tapFailure = exports.tapExpected = exports.tap = exports.sync = exports.suspend = exports.succeedSome = exports.succeedNone = exports.succeed = exports.sleep = exports.serviceOption = exports.service = exports.scoped = exports.scopeUnsafeMake = exports.scopeMake = exports.scope = exports.sandbox = exports.runSyncResult = exports.runSync = exports.runSymbol = exports.runPromiseResult = exports.runPromise = exports.runFork = exports.retry = exports.resultVoid = exports.resultIsSuccess = exports.resultIsFailureUnexpected = exports.resultIsFailureExpected = exports.resultIsFailure = exports.resultIsAborted = exports.repeatResult = exports.repeat = exports.raceFirst = exports.raceAllFirst = exports.raceAll = exports.race = exports.provideServiceMicro = exports.provideService = exports.provideScope = exports.provideContext = exports.promise = exports.orElseSucceed = exports.orDie = exports.option = exports.onResultIf = exports.onResult = exports.onFailure = exports.onAbort = exports.never = exports.matchMicro = void 0;
+var Context = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Context.js"));
+var Effectable = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Effectable.js"));
+var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Either.js"));
+var _Function = /*#__PURE__*/require("./Function.js");
+var _GlobalValue = /*#__PURE__*/require("./GlobalValue.js");
+var _Inspectable = /*#__PURE__*/require("./Inspectable.js");
+var _effectable = /*#__PURE__*/require("./internal/effectable.js");
+var _singleShotGen = /*#__PURE__*/require("./internal/singleShotGen.js");
+var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Option.js"));
+var _Pipeable = /*#__PURE__*/require("./Pipeable.js");
+var _Predicate = /*#__PURE__*/require("./Predicate.js");
+var _Utils = /*#__PURE__*/require("./Utils.js");
+function _getRequireWildcardCache(e) {
+  if ("function" != typeof WeakMap) return null;
+  var r = new WeakMap(),
+    t = new WeakMap();
+  return (_getRequireWildcardCache = function (e) {
+    return e ? t : r;
+  })(e);
+}
+function _interopRequireWildcard(e, r) {
+  if (!r && e && e.__esModule) return e;
+  if (null === e || "object" != typeof e && "function" != typeof e) return {
+    default: e
+  };
+  var t = _getRequireWildcardCache(r);
+  if (t && t.has(e)) return t.get(e);
+  var n = {
+      __proto__: null
+    },
+    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
+    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+  }
+  return n.default = e, t && t.set(e, n), n;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category type ids
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/Micro");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category symbols
+ */
+const runSymbol = exports.runSymbol = /*#__PURE__*/Symbol.for("effect/Micro/runSymbol");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category guards
+ */
+const isMicro = u => typeof u === "object" && u !== null && TypeId in u;
+// ----------------------------------------------------------------------------
+// Failures
+// ----------------------------------------------------------------------------
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.isMicro = isMicro;
+const FailureTypeId = exports.FailureTypeId = /*#__PURE__*/Symbol.for("effect/Micro/Failure");
+const failureVariance = {
+  _E: _Function.identity
+};
+class FailureImpl extends globalThis.Error {
+  _tag;
+  traces;
+  [FailureTypeId];
+  constructor(_tag, originalError, traces) {
+    const failureName = `Failure${_tag}`;
+    let name;
+    let message;
+    let stack;
+    if (originalError instanceof globalThis.Error) {
+      name = `(${failureName}) ${originalError.name}`;
+      message = originalError.message;
+      const messageLines = message.split("\n").length;
+      stack = originalError.stack ? `(${failureName}) ${originalError.stack.split("\n").slice(0, messageLines + 3).join("\n")}` : `${name}: ${message}`;
+    } else {
+      name = failureName;
+      message = (0, _Inspectable.toStringUnknown)(originalError, 0);
+      stack = `${name}: ${message}`;
+    }
+    if (traces.length > 0) {
+      stack += `\n    ${traces.join("\n    ")}`;
+    }
+    super(message);
+    this._tag = _tag;
+    this.traces = traces;
+    this[FailureTypeId] = failureVariance;
+    this.name = name;
+    this.stack = stack;
+  }
+  pipe() {
+    return (0, _Pipeable.pipeArguments)(this, arguments);
+  }
+  toString() {
+    return this.stack;
+  }
+  [_Inspectable.NodeInspectSymbol]() {
+    return this.stack;
+  }
+}
+class FailureExpectedImpl extends FailureImpl {
+  error;
+  constructor(error, traces = []) {
+    super("Expected", error, traces);
+    this.error = error;
+  }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+const FailureExpected = (error, traces = []) => new FailureExpectedImpl(error, traces);
+exports.FailureExpected = FailureExpected;
+class FailureUnexpectedImpl extends FailureImpl {
+  defect;
+  constructor(defect, traces = []) {
+    super("Unexpected", defect, traces);
+    this.defect = defect;
+  }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+const FailureUnexpected = (defect, traces = []) => new FailureUnexpectedImpl(defect, traces);
+exports.FailureUnexpected = FailureUnexpected;
+class FailureAbortedImpl extends FailureImpl {
+  constructor(traces = []) {
+    super("Aborted", "aborted", traces);
+  }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+const FailureAborted = (traces = []) => new FailureAbortedImpl(traces);
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.FailureAborted = FailureAborted;
+const failureIsExpected = self => self._tag === "Expected";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.failureIsExpected = failureIsExpected;
+const failureIsUnexpected = self => self._tag === "Unexpected";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.failureIsUnexpected = failureIsUnexpected;
+const failureIsAborted = self => self._tag === "Aborted";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.failureIsAborted = failureIsAborted;
+const failureSquash = self => self._tag === "Expected" ? self.error : self._tag === "Unexpected" ? self.defect : self;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+exports.failureSquash = failureSquash;
+const failureWithTrace = exports.failureWithTrace = /*#__PURE__*/(0, _Function.dual)(2, (self, trace) => {
+  if (self._tag === "Expected") {
+    return FailureExpected(self.error, [...self.traces, trace]);
+  } else if (self._tag === "Unexpected") {
+    return FailureUnexpected(self.defect, [...self.traces, trace]);
+  }
+  return FailureAborted([...self.traces, trace]);
+});
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const ResultAborted = exports.ResultAborted = /*#__PURE__*/Either.left( /*#__PURE__*/FailureAborted());
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const ResultSuccess = exports.ResultSuccess = Either.right;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const ResultFail = e => Either.left(FailureExpected(e));
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+exports.ResultFail = ResultFail;
+const ResultFailUnexpected = defect => Either.left(FailureUnexpected(defect));
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+exports.ResultFailUnexpected = ResultFailUnexpected;
+const ResultFailWith = exports.ResultFailWith = Either.left;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const resultIsSuccess = exports.resultIsSuccess = Either.isRight;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const resultIsFailure = exports.resultIsFailure = Either.isLeft;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+const resultIsAborted = self => resultIsFailure(self) && self.left._tag === "Aborted";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+exports.resultIsAborted = resultIsAborted;
+const resultIsFailureExpected = self => resultIsFailure(self) && self.left._tag === "Expected";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+exports.resultIsFailureExpected = resultIsFailureExpected;
+const resultIsFailureUnexpected = self => resultIsFailure(self) && self.left._tag === "Unexpected";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+exports.resultIsFailureUnexpected = resultIsFailureUnexpected;
+const resultVoid = exports.resultVoid = /*#__PURE__*/ResultSuccess(void 0);
+// ----------------------------------------------------------------------------
+// env
+// ----------------------------------------------------------------------------
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const EnvTypeId = exports.EnvTypeId = /*#__PURE__*/Symbol.for("effect/Micro/Env");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const EnvRefTypeId = exports.EnvRefTypeId = /*#__PURE__*/Symbol.for("effect/Micro/EnvRef");
+const EnvProto = {
+  [EnvTypeId]: {
+    _R: _Function.identity
+  },
+  pipe() {
+    return (0, _Pipeable.pipeArguments)(this, arguments);
+  }
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const envMake = refs => {
+  const self = Object.create(EnvProto);
+  self.refs = refs;
+  return self;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+exports.envMake = envMake;
+const envUnsafeMakeEmpty = () => {
+  const controller = new AbortController();
+  const refs = Object.create(null);
+  refs[currentAbortController.key] = controller;
+  refs[currentAbortSignal.key] = controller.signal;
+  return envMake(refs);
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+exports.envUnsafeMakeEmpty = envUnsafeMakeEmpty;
+const envGet = exports.envGet = /*#__PURE__*/(0, _Function.dual)(2, (self, ref) => ref.key in self.refs ? self.refs[ref.key] : ref.initial);
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const envSet = exports.envSet = /*#__PURE__*/(0, _Function.dual)(3, (self, ref, value) => {
+  const refs = Object.assign(Object.create(null), self.refs);
+  refs[ref.key] = value;
+  return envMake(refs);
+});
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const envMutate = exports.envMutate = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => envMake(f(Object.assign(Object.create(null), self.refs))));
+/**
+ * Access the given `Context.Tag` from the environment.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const service = tag => make(function (env, onResult) {
+  onResult(ResultSuccess(Context.get(envGet(env, currentContext), tag)));
+});
+/**
+ * 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
+ */
+exports.service = service;
+const serviceOption = tag => make(function (env, onResult) {
+  onResult(ResultSuccess(Context.getOption(envGet(env, currentContext), tag)));
+});
+/**
+ * Retrieve the current value of the given `EnvRef`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+exports.serviceOption = serviceOption;
+const getEnvRef = envRef => make((env, onResult) => onResult(Either.right(envGet(env, envRef))));
+/**
+ * Set the value of the given `EnvRef` for the duration of the effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+exports.getEnvRef = getEnvRef;
+const locally = exports.locally = /*#__PURE__*/(0, _Function.dual)(3, (self, fiberRef, value) => make((env, onResult) => self[runSymbol](envSet(env, fiberRef, value), onResult)));
+/**
+ * Access the current `Context` from the environment.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const context = () => getEnvRef(currentContext);
+/**
+ * Merge the given `Context` with the current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+exports.context = context;
+const provideContext = exports.provideContext = /*#__PURE__*/(0, _Function.dual)(2, (self, provided) => make(function (env, onResult) {
+  const context = envGet(env, currentContext);
+  const nextEnv = envSet(env, currentContext, Context.merge(context, provided));
+  self[runSymbol](nextEnv, onResult);
+}));
+/**
+ * Add the provided service to the current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const provideService = exports.provideService = /*#__PURE__*/(0, _Function.dual)(3, (self, tag, service) => make(function (env, onResult) {
+  const context = envGet(env, currentContext);
+  const nextEnv = envSet(env, currentContext, Context.add(context, tag, service));
+  self[runSymbol](nextEnv, onResult);
+}));
+/**
+ * Create a service using the provided `Micro` effect, and add it to the
+ * current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+const provideServiceMicro = exports.provideServiceMicro = /*#__PURE__*/(0, _Function.dual)(3, (self, tag, acquire) => flatMap(acquire, service => provideService(self, tag, service)));
+// ========================================================================
+// Env refs
+// ========================================================================
+const EnvRefProto = {
+  [EnvRefTypeId]: EnvRefTypeId
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+const envRefMake = (key, initial) => (0, _GlobalValue.globalValue)(key, () => {
+  const self = Object.create(EnvRefProto);
+  self.key = key;
+  self.initial = initial();
+  return self;
+});
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+exports.envRefMake = envRefMake;
+const currentAbortController = exports.currentAbortController = /*#__PURE__*/envRefMake("effect/Micro/currentAbortController", () => new AbortController());
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+const currentAbortSignal = exports.currentAbortSignal = /*#__PURE__*/envRefMake("effect/Micro/currentAbortSignal", () => currentAbortController.initial.signal);
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+const currentContext = exports.currentContext = /*#__PURE__*/envRefMake("effect/Micro/currentContext", () => Context.empty());
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+const currentConcurrency = exports.currentConcurrency = /*#__PURE__*/envRefMake("effect/Micro/currentConcurrency", () => "unbounded");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+const currentMaxDepthBeforeYield = exports.currentMaxDepthBeforeYield = /*#__PURE__*/envRefMake("effect/Micro/currentMaxDepthBeforeYield", () => 2048);
+const currentInterruptible = /*#__PURE__*/envRefMake("effect/Micro/currentInterruptible", () => true);
+/**
+ * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
+ * api to control the concurrency of that `Micro` when it is run.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ * @example
+ * 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
+ * )
+ */
+const withConcurrency = exports.withConcurrency = /*#__PURE__*/(0, _Function.dual)(2, (self, concurrency) => locally(self, currentConcurrency, concurrency));
+// ----------------------------------------------------------------------------
+// constructors
+// ----------------------------------------------------------------------------
+const MicroProto = {
+  ...Effectable.EffectPrototype,
+  _op: "Micro",
+  [TypeId]: {
+    _A: _Function.identity,
+    _E: _Function.identity,
+    _R: _Function.identity
+  },
+  [Symbol.iterator]() {
+    return new _singleShotGen.SingleShotGen(new _Utils.YieldWrap(this));
+  }
+};
+const microDepthState = /*#__PURE__*/(0, _GlobalValue.globalValue)("effect/Micro/microDepthState", () => ({
+  depth: 0,
+  maxDepthBeforeYield: currentMaxDepthBeforeYield.initial
+}));
+const unsafeMake = run => {
+  const self = Object.create(MicroProto);
+  self[runSymbol] = run;
+  return self;
+};
+const unsafeMakeOptions = (run, checkAbort) => unsafeMake(function execute(env, onResult) {
+  if (checkAbort && env.refs[currentInterruptible.key] !== false && env.refs[currentAbortSignal.key].aborted) {
+    return onResult(ResultAborted);
+  }
+  microDepthState.depth++;
+  if (microDepthState.depth === 1) {
+    microDepthState.maxDepthBeforeYield = envGet(env, currentMaxDepthBeforeYield);
+  }
+  if (microDepthState.depth >= microDepthState.maxDepthBeforeYield) {
+    yieldAdd(() => execute(env, onResult));
+  } else {
+    try {
+      run(env, onResult);
+    } catch (err) {
+      onResult(ResultFailUnexpected(err));
+    }
+  }
+  microDepthState.depth--;
+});
+/**
+ * A low-level constructor for creating a `Micro` effect. It takes a function
+ * that receives an environment and a callback which should be called with the
+ * result of the effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const make = run => unsafeMakeOptions(run, true);
+/**
+ * Converts a `Result` into a `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.make = make;
+const fromResult = self => make(function (_env, onResult) {
+  onResult(self);
+});
+/**
+ * Converts a lazy `Result` into a `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.fromResult = fromResult;
+const fromResultSync = self => make(function (_env, onResult) {
+  onResult(self());
+});
+/**
+ * Creates a `Micro` effect that will succeed with the specified constant value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.fromResultSync = fromResultSync;
+const succeed = a => fromResult(ResultSuccess(a));
+/**
+ * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.succeed = succeed;
+const succeedSome = a => succeed(Option.some(a));
+/**
+ * Creates a `Micro` effect that will succeed with `Option.None`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.succeedSome = succeedSome;
+const succeedNone = exports.succeedNone = /*#__PURE__*/succeed( /*#__PURE__*/Option.none());
+/**
+ * Creates a `Micro` effect that will fail with the specified error.
+ *
+ * This will result in a `FailureExpected`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const fail = e => fromResult(ResultFail(e));
+/**
+ * Creates a `Micro` effect that will fail with the lazily evaluated error.
+ *
+ * This will result in a `FailureExpected`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.fail = fail;
+const failSync = e => make(function (_env, onResult) {
+  onResult(ResultFail(e()));
+});
+/**
+ * Creates a `Micro` effect that will die with the specified error.
+ *
+ * This will result in a `FailureUnexpected`, where the error is not tracked at
+ * the type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.failSync = failSync;
+const die = defect => fromResult(ResultFailUnexpected(defect));
+/**
+ * Creates a `Micro` effect that will fail with the specified `Failure`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.die = die;
+const failWith = failure => fromResult(ResultFailWith(failure));
+/**
+ * Creates a `Micro` effect that will fail with the lazily evaluated `Failure`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.failWith = failWith;
+const failWithSync = failure => fromResultSync(() => ResultFailWith(failure()));
+/**
+ * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ *
+ * If the evaluation of the value throws an error, the effect will fail with
+ * `FailureUnexpected`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.failWithSync = failWithSync;
+const sync = evaluate => make(function (_env, onResult) {
+  onResult(ResultSuccess(evaluate()));
+});
+/**
+ * Converts an `Option` into a `Micro` effect, that will fail with a
+ * `Option.None` if the option is `None`. Otherwise, it will succeed with the
+ * value of the option.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.sync = sync;
+const fromOption = option => make(function (_env, onResult) {
+  onResult(option._tag === "Some" ? ResultSuccess(option.value) : ResultFail(Option.none()));
+});
+/**
+ * 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
+ */
+exports.fromOption = fromOption;
+const fromEither = either => make(function (_env, onResult) {
+  onResult(either._tag === "Right" ? either : ResultFail(either.left));
+});
+/**
+ * Lazily creates a `Micro` effect from the given side-effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+exports.fromEither = fromEither;
+const suspend = evaluate => make(function (env, onResult) {
+  evaluate()[runSymbol](env, onResult);
+});
+exports.suspend = suspend;
+const void_ = exports.void = /*#__PURE__*/succeed(void 0);
+/**
+ * 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
+ */
+const async = register => make(function (env, onResult) {
+  let resumed = false;
+  const controller = register.length > 1 ? new AbortController() : undefined;
+  const signal = envGet(env, currentAbortSignal);
+  let cleanup = undefined;
+  function onAbort() {
+    if (cleanup) {
+      resume(uninterruptible(andThen(cleanup, fromResult(ResultAborted))));
+    } else {
+      resume(fromResult(ResultAborted));
+    }
+    if (controller !== undefined) {
+      controller.abort();
+    }
+  }
+  function resume(effect) {
+    if (resumed) {
+      return;
+    }
+    resumed = true;
+    signal.removeEventListener("abort", onAbort);
+    effect[runSymbol](env, onResult);
+  }
+  cleanup = controller === undefined ? register(resume) : register(resume, controller.signal);
+  if (resumed) return;
+  signal.addEventListener("abort", onAbort);
+});
+exports.async = async;
+const try_ = options => make(function (_env, onResult) {
+  try {
+    onResult(ResultSuccess(options.try()));
+  } catch (err) {
+    onResult(ResultFail(options.catch(err)));
+  }
+});
+exports.try = try_;
+/**
+ * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
+ * `FailureUnexpected`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const promise = evaluate => async(function (resume, signal) {
+  evaluate(signal).then(a => resume(succeed(a)), e => resume(die(e)));
+});
+/**
+ * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
+ * converted into a specific error type.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ * @example
+ * import { Micro } from "effect"
+ *
+ * Micro.tryPromise({
+ *   try: () => Promise.resolve("success"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ */
+exports.promise = promise;
+const tryPromise = options => async(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)));
+  }
+});
+exports.tryPromise = tryPromise;
+const yieldState = /*#__PURE__*/(0, _GlobalValue.globalValue)("effect/Micro/yieldState", () => ({
+  tasks: [],
+  working: false
+}));
+const yieldRunTasks = () => {
+  const tasks = yieldState.tasks;
+  yieldState.tasks = [];
+  for (let i = 0, len = tasks.length; i < len; i++) {
+    tasks[i]();
+  }
+};
+const setImmediate = "setImmediate" in globalThis ? globalThis.setImmediate : f => setTimeout(f, 0);
+const yieldAdd = task => {
+  yieldState.tasks.push(task);
+  if (!yieldState.working) {
+    yieldState.working = true;
+    setImmediate(() => {
+      yieldState.working = false;
+      yieldRunTasks();
+    });
+  }
+};
+/**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * iteration of the event loop.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const yieldNow = exports.yieldNow = /*#__PURE__*/make(function (_env, onResult) {
+  yieldAdd(() => onResult(resultVoid));
+});
+/**
+ * Flush any yielded effects that are waiting to be executed.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const yieldFlush = exports.yieldFlush = /*#__PURE__*/sync(function () {
+  while (yieldState.tasks.length > 0) {
+    yieldRunTasks();
+  }
+});
+/**
+ * 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
+ */
+const never = exports.never = /*#__PURE__*/async(function () {
+  const interval = setInterval(_Function.constVoid, 2147483646);
+  return sync(() => clearInterval(interval));
+});
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+const gen = f => make(function (env, onResult) {
+  const iterator = f();
+  let running = false;
+  let value = undefined;
+  function run() {
+    running = true;
+    try {
+      let shouldContinue = true;
+      while (shouldContinue) {
+        const result = iterator.next(value);
+        if (result.done) {
+          return onResult(ResultSuccess(result.value));
+        }
+        shouldContinue = false;
+        (0, _Utils.yieldWrapGet)(result.value)[runSymbol](env, function (result) {
+          if (result._tag === "Left") {
+            onResult(result);
+          } else {
+            shouldContinue = true;
+            value = result.right;
+            if (!running) run();
+          }
+        });
+      }
+    } catch (err) {
+      onResult(ResultFailUnexpected(err));
+    }
+    running = false;
+  }
+  run();
+});
+// ----------------------------------------------------------------------------
+// mapping & sequencing
+// ----------------------------------------------------------------------------
+/**
+ * Flattens any nested `Micro` effects, merging the error and requirement types.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.gen = gen;
+const flatten = self => make(function (env, onResult) {
+  self[runSymbol](env, result => result._tag === "Left" ? onResult(result) : result.right[runSymbol](env, onResult));
+});
+/**
+ * Transforms the success value of the `Micro` effect with the specified
+ * function.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.flatten = flatten;
+const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    onResult(result._tag === "Left" ? result : ResultSuccess(f(result.right)));
+  });
+}));
+/**
+ * Create a `Micro` effect that will replace the success value of the given
+ * effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+const as = exports.as = /*#__PURE__*/(0, _Function.dual)(2, (self, value) => map(self, _ => value));
+/**
+ * Wrap the success value of this `Micro` effect in an `Option.Some`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+const asSome = self => map(self, Option.some);
+/**
+ * Map the success value of this `Micro` effect to another `Micro` effect, then
+ * flatten the result.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.asSome = asSome;
+const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    if (result._tag === "Left") {
+      return onResult(result);
+    }
+    f(result.right)[runSymbol](env, onResult);
+  });
+}));
+/**
+ * Swap the error and success types of the `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+const flip = self => matchMicro(self, {
+  onFailure: succeed,
+  onSuccess: fail
+});
+/**
+ * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+ * a single api.
+ *
+ * It also allows you to pass in a `Micro` effect directly, which will be
+ * executed after the current effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.flip = flip;
+const andThen = exports.andThen = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    if (result._tag === "Left") {
+      return onResult(result);
+    } else if (envGet(env, currentAbortSignal).aborted) {
+      return onResult(ResultAborted);
+    }
+    const value = isMicro(f) ? f : typeof f === "function" ? f(result.right) : f;
+    if (isMicro(value)) {
+      value[runSymbol](env, onResult);
+    } else {
+      onResult(ResultSuccess(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
+ */
+const tap = exports.tap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => make(function (env, onResult) {
+  self[runSymbol](env, function (selfResult) {
+    if (selfResult._tag === "Left") {
+      return onResult(selfResult);
+    } else if (envGet(env, currentAbortSignal).aborted) {
+      return onResult(ResultAborted);
+    }
+    const value = isMicro(f) ? f : typeof f === "function" ? f(selfResult.right) : f;
+    if (isMicro(value)) {
+      value[runSymbol](env, function (tapResult) {
+        if (tapResult._tag === "Left") {
+          return onResult(tapResult);
+        }
+        onResult(selfResult);
+      });
+    } else {
+      onResult(selfResult);
+    }
+  });
+}));
+/**
+ * Replace the success value of the `Micro` effect with `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+const asVoid = self => map(self, _ => void 0);
+/**
+ * Access the `Result` of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.asVoid = asVoid;
+const asResult = self => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    onResult(ResultSuccess(result));
+  });
+});
+/**
+ * Replace the error type of the given `Micro` with the full `Failure` object.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+exports.asResult = asResult;
+const sandbox = self => catchFailure(self, failure => fail(failure));
+exports.sandbox = sandbox;
+function forkSignal(env) {
+  const controller = new AbortController();
+  const parentSignal = envGet(env, currentAbortSignal);
+  function onAbort() {
+    controller.abort();
+    parentSignal.removeEventListener("abort", onAbort);
+  }
+  parentSignal.addEventListener("abort", onAbort);
+  const envWithSignal = envMutate(env, function (refs) {
+    refs[currentAbortController.key] = controller;
+    refs[currentAbortSignal.key] = controller.signal;
+    return refs;
+  });
+  return [envWithSignal, onAbort];
+}
+/**
+ * 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
+ */
+const raceAll = all => make(function (env, onResult) {
+  const [envWithSignal, onAbort] = forkSignal(env);
+  const effects = Array.from(all);
+  let len = effects.length;
+  let index = 0;
+  let done = 0;
+  let result = undefined;
+  const failures = [];
+  function onDone(result_) {
+    done++;
+    if (result_._tag === "Right" && result === undefined) {
+      len = index;
+      result = result_;
+      onAbort();
+    } else if (result_._tag === "Left") {
+      failures.push(result_.left);
+    }
+    if (done >= len) {
+      onResult(result ?? Either.left(failures[0]));
+    }
+  }
+  for (; index < len; index++) {
+    effects[index][runSymbol](envWithSignal, onDone);
+  }
+});
+/**
+ * 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
+ */
+exports.raceAll = raceAll;
+const raceAllFirst = all => make(function (env, onResult) {
+  const [envWithSignal, onAbort] = forkSignal(env);
+  const effects = Array.from(all);
+  let len = effects.length;
+  let index = 0;
+  let done = 0;
+  let result = undefined;
+  const failures = [];
+  function onDone(result_) {
+    done++;
+    if (result === undefined) {
+      len = index;
+      result = result_;
+      onAbort();
+    }
+    if (done >= len) {
+      onResult(result ?? Either.left(failures[0]));
+    }
+  }
+  for (; index < len; index++) {
+    effects[index][runSymbol](envWithSignal, onDone);
+  }
+});
+/**
+ * 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
+ */
+exports.raceAllFirst = raceAllFirst;
+const race = exports.race = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => 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
+ */
+const raceFirst = exports.raceFirst = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => raceAllFirst([self, that]));
+// ----------------------------------------------------------------------------
+// zipping
+// ----------------------------------------------------------------------------
+/**
+ * Combine two `Micro` effects into a single effect that produces a tuple of
+ * their results.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category zipping
+ */
+const zip = exports.zip = /*#__PURE__*/(0, _Function.dual)(args => isMicro(args[1]), (self, that, options) => {
+  if (options?.concurrent) {
+    return all([self, that], {
+      concurrency: "unbounded"
+    });
+  }
+  return flatMap(self, a => map(that, a2 => [a, a2]));
+});
+// ----------------------------------------------------------------------------
+// filtering & conditionals
+// ----------------------------------------------------------------------------
+/**
+ * Filter the specified effect with the provided function, failing with specified
+ * `Failure` 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
+ */
+const filterOrFailWith = exports.filterOrFailWith = /*#__PURE__*/(0, _Function.dual)(args => isMicro(args[0]), (self, refinement, orFailWith) => flatMap(self, a => refinement(a) ? succeed(a) : failWith(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
+ */
+const filterOrFail = exports.filterOrFail = /*#__PURE__*/(0, _Function.dual)(args => isMicro(args[0]), (self, refinement, orFailWith) => 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
+ */
+const when = exports.when = /*#__PURE__*/(0, _Function.dual)(2, (self, condition) => flatMap(isMicro(condition) ? condition : sync(condition), pass => pass ? asSome(self) : succeed(Option.none())));
+// ----------------------------------------------------------------------------
+// repetition
+// ----------------------------------------------------------------------------
+/**
+ * Repeat the given `Micro` using the provided options.
+ *
+ * The `while` predicate will be checked after each iteration, and can use the
+ * fall `Result` of the effect to determine if the repetition should continue.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+const repeatResult = exports.repeatResult = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => make(function (env, onResult) {
+  const startedAt = options.delay ? Date.now() : 0;
+  let attempt = 0;
+  self[runSymbol](env, function loop(result) {
+    if (options.while !== undefined && !options.while(result)) {
+      return onResult(result);
+    } else if (options.times !== undefined && attempt >= options.times) {
+      return onResult(result);
+    }
+    attempt++;
+    let delayEffect = yieldNow;
+    if (options.delay !== undefined) {
+      const elapsed = Date.now() - startedAt;
+      const duration = options.delay(attempt, elapsed);
+      if (Option.isNone(duration)) {
+        return onResult(result);
+      }
+      delayEffect = sleep(duration.value);
+    }
+    delayEffect[runSymbol](env, function (result) {
+      if (result._tag === "Left") {
+        return onResult(result);
+      }
+      self[runSymbol](env, loop);
+    });
+  });
+}));
+/**
+ * Repeat the given `Micro` effect using the provided options. Only successful
+ * results will be repeated.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+const repeat = exports.repeat = /*#__PURE__*/(0, _Function.dual)(args => isMicro(args[0]), (self, options) => repeatResult(self, {
+  ...options,
+  while: result => result._tag === "Right" && (options?.while === undefined || options.while(result.right))
+}));
+/**
+ * Repeat the given `Micro` effect forever, only stopping if the effect fails.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+const forever = self => repeat(self);
+/**
+ * Create a `DelayFn` that will generate a duration with an exponential backoff.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+exports.forever = forever;
+const delayExponential = (baseMillis, factor = 2) => attempt => Option.some(attempt ** factor * baseMillis);
+/**
+ * Create a `DelayFn` that will generate a duration with fixed intervals.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+exports.delayExponential = delayExponential;
+const delaySpaced = millis => _ => Option.some(millis);
+/**
+ * Transform a `DelayFn` to one that will have a duration that will never exceed
+ * the specified maximum.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+exports.delaySpaced = delaySpaced;
+const delayWithMax = exports.delayWithMax = /*#__PURE__*/(0, _Function.dual)(2, (self, max) => (attempt, elapsed) => Option.map(self(attempt, elapsed), duration => Math.min(duration, max)));
+/**
+ * Transform a `DelayFn` to one that will stop repeating after the specified
+ * amount of time.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+const delayWithMaxElapsed = exports.delayWithMaxElapsed = /*#__PURE__*/(0, _Function.dual)(2, (self, max) => (attempt, elapsed) => elapsed < max ? self(attempt, elapsed) : Option.none());
+/**
+ * Transform a `DelayFn` to one that will stop repeating after the specified
+ * number of attempts.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+const delayWithRecurs = exports.delayWithRecurs = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => (attempt, elapsed) => Option.filter(self(attempt, elapsed), () => attempt <= n));
+// ----------------------------------------------------------------------------
+// error handling
+// ----------------------------------------------------------------------------
+/**
+ * Catch the full `Failure` object of the given `Micro` effect, allowing you to
+ * recover from any kind of failure.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchFailure = exports.catchFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchFailureIf(self, _Function.constTrue, f));
+/**
+ * Selectively catch a `Failure` object of the given `Micro` effect,
+ * using the provided predicate to determine if the failure should be caught.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchFailureIf = exports.catchFailureIf = /*#__PURE__*/(0, _Function.dual)(3, (self, refinement, f) => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    if (result._tag === "Right" || !refinement(result.left)) {
+      return onResult(result);
+    }
+    f(result.left)[runSymbol](env, onResult);
+  });
+}));
+/**
+ * Catch the error of the given `Micro` effect, allowing you to recover from it.
+ *
+ * It only catches expected (`FailureExpected`) errors.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchExpected = exports.catchExpected = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchFailureIf(self, failureIsExpected, failure => f(failure.error)));
+/**
+ * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchUnexpected = exports.catchUnexpected = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchFailureIf(self, failureIsUnexpected, failure => f(failure.defect)));
+/**
+ * Perform a side effect using the full `Failure` object of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const tapFailure = exports.tapFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => tapFailureIf(self, _Function.constTrue, f));
+/**
+ * Perform a side effect using if a `Failure` object matches the specified
+ * predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const tapFailureIf = exports.tapFailureIf = /*#__PURE__*/(0, _Function.dual)(3, (self, refinement, f) => catchFailureIf(self, refinement, failure => andThen(f(failure), failWith(failure))));
+/**
+ * Perform a side effect from expected errors of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const tapExpected = exports.tapExpected = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => tapFailureIf(self, failureIsExpected, failure => f(failure.error)));
+/**
+ * Perform a side effect from unexpected errors of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const tapUnexpected = exports.tapUnexpected = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => tapFailureIf(self, failureIsUnexpected, failure => f(failure.defect)));
+/**
+ * Catch any expected errors that match the specified predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchIf = exports.catchIf = /*#__PURE__*/(0, _Function.dual)(3, (self, pred, f) => catchFailureIf(self, f => failureIsExpected(f) && pred(f.error), failure => f(failure.error)));
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const catchTag = exports.catchTag = /*#__PURE__*/(0, _Function.dual)(3, (self, k, f) => catchIf(self, error => (0, _Predicate.isTagged)(error, k), f));
+/**
+ * Transform the full `Failure` object of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const mapFailure = exports.mapFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchFailure(self, failure => failWith(f(failure))));
+/**
+ * Transform any expected errors of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const mapError = exports.mapError = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchExpected(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
+ */
+const orDie = self => catchExpected(self, die);
+/**
+ * Recover from all errors by succeeding with the given value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+exports.orDie = orDie;
+const orElseSucceed = exports.orElseSucceed = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => catchExpected(self, _ => sync(f)));
+/**
+ * Ignore any expected errors of the given `Micro` effect, returning `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const ignore = self => matchMicro(self, {
+  onFailure: _ => void_,
+  onSuccess: _ => void_
+});
+/**
+ * Ignore any expected errors of the given `Micro` effect, returning `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+exports.ignore = ignore;
+const ignoreLogged = self => matchMicro(self, {
+  onFailure: failure => sync(() => console.error(failure)),
+  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
+ */
+exports.ignoreLogged = ignoreLogged;
+const option = self => 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
+ */
+exports.option = option;
+const either = self => 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
+ */
+exports.either = either;
+const retry = exports.retry = /*#__PURE__*/(0, _Function.dual)(args => isMicro(args[0]), (self, options) => repeatResult(self, {
+  ...options,
+  while: result => result._tag === "Left" && result.left._tag === "Expected" && (options?.while === undefined || options.while(result.left.error))
+}));
+/**
+ * Add a stack trace to any failures that occur in the effect. The trace will be
+ * added to the `traces` field of the `Failure` object.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+const withTrace = function () {
+  const prevLimit = globalThis.Error.stackTraceLimit;
+  globalThis.Error.stackTraceLimit = 2;
+  const error = new globalThis.Error();
+  globalThis.Error.stackTraceLimit = prevLimit;
+  function generate(name, failure) {
+    const stack = error.stack;
+    if (!stack) {
+      return failure;
+    }
+    const line = stack.split("\n")[2]?.trim().replace(/^at /, "");
+    if (!line) {
+      return failure;
+    }
+    const lineMatch = line.match(/\((.*)\)$/);
+    return failureWithTrace(failure, `at ${name} (${lineMatch ? lineMatch[1] : line})`);
+  }
+  const f = name => self => unsafeMakeOptions(function (env, onResult) {
+    self[runSymbol](env, function (result) {
+      onResult(result._tag === "Left" ? Either.left(generate(name, result.left)) : result);
+    });
+  }, false);
+  if (arguments.length === 2) {
+    return f(arguments[1])(arguments[0]);
+  }
+  return f(arguments[0]);
+};
+// ----------------------------------------------------------------------------
+// pattern matching
+// ----------------------------------------------------------------------------
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+exports.withTrace = withTrace;
+const matchFailureMicro = exports.matchFailureMicro = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => make(function (env, onResult) {
+  self[runSymbol](env, function (result) {
+    try {
+      const next = result._tag === "Left" ? options.onFailure(result.left) : options.onSuccess(result.right);
+      next[runSymbol](env, onResult);
+    } catch (err) {
+      onResult(ResultFailUnexpected(err));
+    }
+  });
+}));
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+const matchFailure = exports.matchFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => matchFailureMicro(self, {
+  onFailure: failure => sync(() => options.onFailure(failure)),
+  onSuccess: value => sync(() => options.onSuccess(value))
+}));
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+const matchMicro = exports.matchMicro = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => matchFailureMicro(self, {
+  onFailure: failure => failure._tag === "Expected" ? options.onFailure(failure.error) : failWith(failure),
+  onSuccess: options.onSuccess
+}));
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => matchMicro(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
+ */
+const sleep = millis => async(function (resume) {
+  const timeout = setTimeout(function () {
+    resume(void_);
+  }, millis);
+  return sync(() => {
+    return 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
+ */
+exports.sleep = sleep;
+const delay = exports.delay = /*#__PURE__*/(0, _Function.dual)(2, (self, millis) => 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
+ */
+const timeoutOrElse = exports.timeoutOrElse = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => raceFirst(self, andThen(interruptible(sleep(options.duration)), options.onTimeout)));
+/**
+ * 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
+ */
+const timeout = exports.timeout = /*#__PURE__*/(0, _Function.dual)(2, (self, millis) => raceFirst(asSome(self), as(interruptible(sleep(millis)), Option.none())));
+// ----------------------------------------------------------------------------
+// resources & finalization
+// ----------------------------------------------------------------------------
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const MicroScopeTypeId = exports.MicroScopeTypeId = /*#__PURE__*/Symbol.for("effect/Micro/MicroScope");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const MicroScope = exports.MicroScope = /*#__PURE__*/Context.GenericTag("effect/Micro/MicroScope");
+class ScopeImpl {
+  [MicroScopeTypeId];
+  state = {
+    _tag: "Open",
+    finalizers: new Set()
+  };
+  constructor() {
+    this[MicroScopeTypeId] = MicroScopeTypeId;
+  }
+  unsafeAddFinalizer(finalizer) {
+    if (this.state._tag === "Open") {
+      this.state.finalizers.add(finalizer);
+    }
+  }
+  addFinalizer(finalizer) {
+    return suspend(() => {
+      if (this.state._tag === "Open") {
+        this.state.finalizers.add(finalizer);
+        return void_;
+      }
+      return finalizer(this.state.result);
+    });
+  }
+  unsafeRemoveFinalizer(finalizer) {
+    if (this.state._tag === "Open") {
+      this.state.finalizers.delete(finalizer);
+    }
+  }
+  close(result) {
+    return suspend(() => {
+      if (this.state._tag === "Open") {
+        const finalizers = Array.from(this.state.finalizers).reverse();
+        this.state = {
+          _tag: "Closed",
+          result
+        };
+        return flatMap(forEach(finalizers, finalizer => asResult(finalizer(result))), results => asVoid(fromResult(Either.all(results))));
+      }
+      return void_;
+    });
+  }
+  get fork() {
+    return sync(() => {
+      const newScope = new ScopeImpl();
+      if (this.state._tag === "Closed") {
+        newScope.state = this.state;
+        return newScope;
+      }
+      function fin(result) {
+        return newScope.close(result);
+      }
+      this.state.finalizers.add(fin);
+      newScope.unsafeAddFinalizer(_ => sync(() => this.unsafeRemoveFinalizer(fin)));
+      return newScope;
+    });
+  }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const scopeMake = exports.scopeMake = /*#__PURE__*/sync(() => new ScopeImpl());
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const scopeUnsafeMake = () => new ScopeImpl();
+/**
+ * Access the current `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+exports.scopeUnsafeMake = scopeUnsafeMake;
+const scope = exports.scope = /*#__PURE__*/service(MicroScope);
+/**
+ * Provide a `MicroScope` to an effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const provideScope = exports.provideScope = /*#__PURE__*/(0, _Function.dual)(2, (self, scope) => 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
+ */
+const scoped = self => suspend(function () {
+  const scope = new ScopeImpl();
+  return onResult(provideService(self, MicroScope, scope), result => scope.close(result));
+});
+/**
+ * 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
+ */
+exports.scoped = scoped;
+const acquireRelease = (acquire, release) => uninterruptible(flatMap(scope, scope => tap(acquire, a => scope.addFinalizer(result => release(a, result)))));
+/**
+ * Add a finalizer to the current `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+exports.acquireRelease = acquireRelease;
+const addFinalizer = finalizer => flatMap(scope, scope => scope.addFinalizer(finalizer));
+/**
+ * When the `Micro` effect is completed, run the given finalizer effect with the
+ * `Result` of the executed effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+exports.addFinalizer = addFinalizer;
+const onResult = exports.onResult = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => onResultIf(self, _Function.constTrue, f));
+/**
+ * When the `Micro` effect is completed, run the given finalizer effect if it
+ * matches the specified predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const onResultIf = exports.onResultIf = /*#__PURE__*/(0, _Function.dual)(3, (self, refinement, f) => uninterruptibleMask(restore => make(function (env, onResult) {
+  restore(self)[runSymbol](env, function (result) {
+    if (!refinement(result)) {
+      return onResult(result);
+    }
+    f(result)[runSymbol](env, function (finalizerResult) {
+      if (finalizerResult._tag === "Left") {
+        return onResult(finalizerResult);
+      }
+      onResult(result);
+    });
+  });
+})));
+/**
+ * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const ensuring = exports.ensuring = /*#__PURE__*/(0, _Function.dual)(2, (self, finalizer) => onResult(self, _ => finalizer));
+/**
+ * When the `Micro` effect fails, run the given finalizer effect with the
+ * `Failure` of the executed effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const onFailure = exports.onFailure = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => onResultIf(self, resultIsFailure, result => f(result.left)));
+/**
+ * If this `Micro` effect is aborted, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+const onAbort = exports.onAbort = /*#__PURE__*/(0, _Function.dual)(2, (self, finalizer) => onResultIf(self, resultIsAborted, _ => 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
+ */
+const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(asResult(restore(use(a))), result => andThen(release(a, result), fromResult(result)))));
+// ----------------------------------------------------------------------------
+// interruption
+// ----------------------------------------------------------------------------
+/**
+ * Abort the current `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+exports.acquireUseRelease = acquireUseRelease;
+const abort = exports.abort = /*#__PURE__*/make(function (env, onResult) {
+  const controller = envGet(env, currentAbortController);
+  controller.abort();
+  onResult(ResultAborted);
+});
+/**
+ * Wrap the given `Micro` effect in an uninterruptible region, preventing the
+ * effect from being aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+const uninterruptible = self => unsafeMakeOptions(function (env, onResult) {
+  const nextEnv = envMutate(env, function (env) {
+    env[currentInterruptible.key] = false;
+    env[currentAbortSignal.key] = new AbortController().signal;
+    return env;
+  });
+  self[runSymbol](nextEnv, onResult);
+}, false);
+/**
+ * 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.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * Micro.uninterruptibleMask((restore) =>
+ *   Micro.sleep(1000).pipe( // uninterruptible
+ *     Micro.andThen(restore(Micro.sleep(1000))) // interruptible
+ *   )
+ * )
+ */
+exports.uninterruptible = uninterruptible;
+const uninterruptibleMask = f => unsafeMakeOptions((env, onResult) => {
+  const isInterruptible = envGet(env, currentInterruptible);
+  const effect = isInterruptible ? f(interruptible) : f(_Function.identity);
+  const nextEnv = isInterruptible ? envMutate(env, function (env) {
+    env[currentInterruptible.key] = false;
+    env[currentAbortSignal.key] = new AbortController().signal;
+    return env;
+  }) : env;
+  effect[runSymbol](nextEnv, onResult);
+}, false);
+/**
+ * Wrap the given `Micro` effect in an interruptible region, allowing the effect
+ * to be aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+exports.uninterruptibleMask = uninterruptibleMask;
+const interruptible = self => make((env, onResult) => {
+  const isInterruptible = envGet(env, currentInterruptible);
+  let newEnv = env;
+  if (!isInterruptible) {
+    const controller = envGet(env, currentAbortController);
+    newEnv = envMutate(env, function (env) {
+      env[currentInterruptible.key] = true;
+      env[currentAbortSignal.key] = controller.signal;
+      return env;
+    });
+  }
+  self[runSymbol](newEnv, onResult);
+});
+/**
+ * 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
+ */
+exports.interruptible = interruptible;
+const all = (arg, options) => {
+  if (Array.isArray(arg) || (0, _Predicate.isIterable)(arg)) {
+    return forEach(arg, _Function.identity, options);
+  } else if (options?.discard) {
+    return forEach(Object.values(arg), _Function.identity, options);
+  }
+  return suspend(() => {
+    const out = {};
+    return as(forEach(Object.entries(arg), ([key, effect]) => map(effect, value => {
+      out[key] = value;
+    }), {
+      discard: true,
+      concurrency: options?.concurrency
+    }), out);
+  });
+};
+/**
+ * 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 in
+ * parallel. By default, the effects are run sequentially.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+exports.all = all;
+const forEach = (iterable, f, options) => make(function (env, onResult) {
+  const concurrencyOption = options?.concurrency === "inherit" ? envGet(env, currentConcurrency) : options?.concurrency ?? 1;
+  const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
+  // abort
+  const [envWithSignal, onAbort] = forkSignal(env);
+  // iterate
+  let failure = undefined;
+  const items = Array.from(iterable);
+  let length = items.length;
+  const out = options?.discard ? undefined : new Array(length);
+  let index = 0;
+  let inProgress = 0;
+  let doneCount = 0;
+  let pumping = false;
+  function pump() {
+    pumping = true;
+    while (inProgress < concurrency && index < length) {
+      const currentIndex = index;
+      const item = items[currentIndex];
+      index++;
+      inProgress++;
+      try {
+        f(item, currentIndex)[runSymbol](envWithSignal, function (result) {
+          if (result._tag === "Left") {
+            if (failure === undefined) {
+              failure = result;
+              length = index;
+              onAbort();
+            }
+          } else if (out !== undefined) {
+            out[currentIndex] = result.right;
+          }
+          doneCount++;
+          inProgress--;
+          if (doneCount === length) {
+            onResult(failure ?? Either.right(out));
+          } else if (!pumping && inProgress < concurrency) {
+            pump();
+          }
+        });
+      } catch (err) {
+        failure = ResultFailUnexpected(err);
+        length = index;
+        onAbort();
+      }
+    }
+    pumping = false;
+  }
+  pump();
+});
+/**
+ * Effectfully filter the elements of the provided iterable.
+ *
+ * Use the `concurrency` option to control how many elements are processed in parallel.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+exports.forEach = forEach;
+const filter = (iterable, f, options) => filterMap(iterable, a => map(f(a), pass => {
+  pass = options?.negate ? !pass : pass;
+  return pass ? Option.some(a) : Option.none();
+}));
+/**
+ * Effectfully filter the elements of the provided iterable.
+ *
+ * Use the `concurrency` option to control how many elements are processed in parallel.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+exports.filter = filter;
+const filterMap = (iterable, f, options) => suspend(() => {
+  const out = [];
+  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
+ */
+exports.filterMap = filterMap;
+const Do = exports.Do = /*#__PURE__*/succeed({});
+/**
+ * Bind the success value of this `Micro` effect to the provided name.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+const bindTo = exports.bindTo = /*#__PURE__*/(0, _Function.dual)(2, (self, name) => map(self, f => ({
+  [name]: f
+})));
+/**
+ * Bind the success value of this `Micro` effect to the provided name.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+const bind = exports.bind = /*#__PURE__*/(0, _Function.dual)(3, (self, name, f) => flatMap(self, a => map(f(a), b => ({
+  ...a,
+  [name]: b
+}))));
+const let_ = exports.let = /*#__PURE__*/(0, _Function.dual)(3, (self, name, f) => map(self, a => ({
+  ...a,
+  [name]: f(a)
+})));
+// ----------------------------------------------------------------------------
+// handle & forking
+// ----------------------------------------------------------------------------
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+const HandleTypeId = exports.HandleTypeId = /*#__PURE__*/Symbol.for("effect/Micro/Handle");
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+const isHandle = u => typeof u === "object" && u !== null && HandleTypeId in u;
+exports.isHandle = isHandle;
+class HandleImpl {
+  parentSignal;
+  [HandleTypeId];
+  observers = new Set();
+  _result = undefined;
+  _controller;
+  isRoot;
+  constructor(parentSignal, controller) {
+    this.parentSignal = parentSignal;
+    this[HandleTypeId] = HandleTypeId;
+    this.isRoot = controller !== undefined;
+    this._controller = controller ?? new AbortController();
+    if (!this.isRoot) {
+      parentSignal.addEventListener("abort", this.unsafeAbort);
+    }
+  }
+  unsafePoll() {
+    return this._result ?? null;
+  }
+  unsafeAbort = () => {
+    this._controller.abort();
+  };
+  emit(result) {
+    if (this._result) {
+      return;
+    }
+    this._result = result;
+    if (!this.isRoot) {
+      this.parentSignal.removeEventListener("abort", this.unsafeAbort);
+    }
+    this.observers.forEach(observer => observer(result));
+    this.observers.clear();
+  }
+  addObserver(observer) {
+    if (this._result) {
+      return observer(this._result);
+    }
+    this.observers.add(observer);
+  }
+  removeObserver(observer) {
+    this.observers.delete(observer);
+  }
+  get await() {
+    return suspend(() => {
+      if (this._result) {
+        return succeed(this._result);
+      }
+      return async(resume => {
+        function observer(result) {
+          resume(succeed(result));
+        }
+        this.addObserver(observer);
+        return sync(() => {
+          this.removeObserver(observer);
+        });
+      });
+    });
+  }
+  get join() {
+    return flatMap(this.await, fromResult);
+  }
+  get abort() {
+    return suspend(() => {
+      this.unsafeAbort();
+      return this.await;
+    });
+  }
+}
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * When the parent `Micro` finishes, this `Micro` will be aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+const fork = self => make(function (env, onResult) {
+  const signal = envGet(env, currentAbortSignal);
+  const handle = new HandleImpl(signal);
+  const nextEnv = envMutate(env, map => {
+    map[currentAbortController.key] = handle._controller;
+    map[currentAbortSignal.key] = handle._controller.signal;
+    return map;
+  });
+  yieldAdd(() => {
+    self[runSymbol](nextEnv, result => {
+      handle.emit(result);
+    });
+  });
+  onResult(Either.right(handle));
+});
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * It will not be aborted when the parent `Micro` finishes.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+exports.fork = fork;
+const forkDaemon = self => make(function (env, onResult) {
+  const controller = new AbortController();
+  const handle = new HandleImpl(controller.signal, controller);
+  const nextEnv = envMutate(env, map => {
+    map[currentAbortController.key] = controller;
+    map[currentAbortSignal.key] = controller.signal;
+    return map;
+  });
+  yieldAdd(() => {
+    self[runSymbol](nextEnv, result => {
+      handle.emit(result);
+    });
+  });
+  onResult(Either.right(handle));
+});
+/**
+ * Run the `Micro` effect in a new `Handle` 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 handle & forking
+ */
+exports.forkDaemon = forkDaemon;
+const forkIn = exports.forkIn = /*#__PURE__*/(0, _Function.dual)(2, (self, scope) => uninterruptibleMask(restore => flatMap(scope.fork, scope => tap(restore(forkDaemon(onResult(self, result => scope.close(result)))), fiber => scope.addFinalizer(_ => asVoid(fiber.abort))))));
+/**
+ * Run the `Micro` effect in a new `Handle` 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 handle & forking
+ */
+const forkScoped = self => flatMap(scope, scope => forkIn(self, scope));
+// ----------------------------------------------------------------------------
+// execution
+// ----------------------------------------------------------------------------
+/**
+ * Execute the `Micro` effect and return a `Handle` that can be awaited, joined,
+ * or aborted.
+ *
+ * You can listen for the result by adding an observer using the handle's
+ * `addObserver` method.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * const handle = Micro.succeed(42).pipe(
+ *   Micro.delay(1000),
+ *   Micro.runFork
+ * )
+ *
+ * handle.addObserver((result) => {
+ *   console.log(result)
+ * })
+ */
+exports.forkScoped = forkScoped;
+const runFork = (effect, options) => {
+  const controller = new AbortController();
+  const refs = Object.create(null);
+  refs[currentAbortController.key] = controller;
+  refs[currentAbortSignal.key] = controller.signal;
+  const env = envMake(refs);
+  const handle = new HandleImpl(controller.signal, controller);
+  effect[runSymbol](envSet(env, currentAbortSignal, handle._controller.signal), result => {
+    handle.emit(result);
+  });
+  if (options?.signal) {
+    if (options.signal.aborted) {
+      handle.unsafeAbort();
+    } else {
+      options.signal.addEventListener("abort", () => handle.unsafeAbort());
+    }
+  }
+  return handle;
+};
+/**
+ * Execute the `Micro` effect and return a `Promise` that resolves with the
+ * `Result` of the computation.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+exports.runFork = runFork;
+const runPromiseResult = (effect, options) => 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
+ */
+exports.runPromiseResult = runPromiseResult;
+const runPromise = (effect, options) => runPromiseResult(effect, options).then(result => {
+  if (result._tag === "Left") {
+    throw result.left;
+  }
+  return result.right;
+});
+/**
+ * Attempt to execute the `Micro` effect synchronously and return the `Result`.
+ *
+ * If any asynchronous effects are encountered, the function will return a
+ * FailureUnexpected containing the `Handle`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+exports.runPromise = runPromise;
+const runSyncResult = effect => {
+  const handle = runFork(effect);
+  while (yieldState.tasks.length > 0) {
+    yieldRunTasks();
+  }
+  const result = handle.unsafePoll();
+  if (result === null) {
+    return ResultFailUnexpected(handle);
+  }
+  return result;
+};
+/**
+ * Attempt to execute the `Micro` effect synchronously and return the success
+ * value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+exports.runSyncResult = runSyncResult;
+const runSync = effect => {
+  const result = runSyncResult(effect);
+  if (result._tag === "Left") {
+    throw result.left;
+  }
+  return result.right;
+};
+exports.runSync = runSync;
+const YieldableError = /*#__PURE__*/function () {
+  class YieldableError extends globalThis.Error {
+    [runSymbol](_env, onResult) {
+      onResult(ResultFail(this));
+    }
+    toString() {
+      return this.message ? `${this.name}: ${this.message}` : this.name;
+    }
+    toJSON() {
+      return {
+        ...this
+      };
+    }
+    [_Inspectable.NodeInspectSymbol]() {
+      const stack = this.stack;
+      if (stack) {
+        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`;
+      }
+      return this.toString();
+    }
+  }
+  Object.assign(YieldableError.prototype, MicroProto, _effectable.StructuralPrototype);
+  return YieldableError;
+}();
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category errors
+ */
+const Error = exports.Error = /*#__PURE__*/function () {
+  return class extends YieldableError {
+    constructor(args) {
+      super();
+      if (args) {
+        Object.assign(this, args);
+      }
+    }
+  };
+}();
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category errors
+ */
+const TaggedError = tag => {
+  class Base extends Error {
+    _tag = tag;
+  }
+  ;
+  Base.prototype.name = tag;
+  return Base;
+};
+exports.TaggedError = TaggedError;
+//# sourceMappingURL=Micro.js.map